1/* 2 * fs/logfs/inode.c - inode handling code 3 * 4 * As should be obvious for Linux kernel code, license is GPLv2 5 * 6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> 7 */ 8#include "logfs.h" 9#include <linux/slab.h> 10#include <linux/writeback.h> 11#include <linux/backing-dev.h> 12 13/* 14 * How soon to reuse old inode numbers? LogFS doesn't store deleted inodes 15 * on the medium. It therefore also lacks a method to store the previous 16 * generation number for deleted inodes. Instead a single generation number 17 * is stored which will be used for new inodes. Being just a 32bit counter, 18 * this can obvious wrap relatively quickly. So we only reuse inodes if we 19 * know that a fair number of inodes can be created before we have to increment 20 * the generation again - effectively adding some bits to the counter. 21 * But being too aggressive here means we keep a very large and very sparse 22 * inode file, wasting space on indirect blocks. 23 * So what is a good value? Beats me. 64k seems moderately bad on both 24 * fronts, so let's use that for now... 25 * 26 * NFS sucks, as everyone already knows. 27 */ 28#define INOS_PER_WRAP (0x10000) 29 30/* 31 * Logfs' requirement to read inodes for garbage collection makes life a bit 32 * harder. GC may have to read inodes that are in I_FREEING state, when they 33 * are being written out - and waiting for GC to make progress, naturally. 34 * 35 * So we cannot just call iget() or some variant of it, but first have to check 36 * whether the inode in question might be in I_FREEING state. Therefore we 37 * maintain our own per-sb list of "almost deleted" inodes and check against 38 * that list first. Normally this should be at most 1-2 entries long. 39 * 40 * Also, inodes have logfs-specific reference counting on top of what the vfs 41 * does. When .destroy_inode is called, normally the reference count will drop 42 * to zero and the inode gets deleted. But if GC accessed the inode, its 43 * refcount will remain nonzero and final deletion will have to wait. 44 * 45 * As a result we have two sets of functions to get/put inodes: 46 * logfs_safe_iget/logfs_safe_iput - safe to call from GC context 47 * logfs_iget/iput - normal version 48 */ 49static struct kmem_cache *logfs_inode_cache; 50 51static DEFINE_SPINLOCK(logfs_inode_lock); 52 53static void logfs_inode_setops(struct inode *inode) 54{ 55 switch (inode->i_mode & S_IFMT) { 56 case S_IFDIR: 57 inode->i_op = &logfs_dir_iops; 58 inode->i_fop = &logfs_dir_fops; 59 inode->i_mapping->a_ops = &logfs_reg_aops; 60 break; 61 case S_IFREG: 62 inode->i_op = &logfs_reg_iops; 63 inode->i_fop = &logfs_reg_fops; 64 inode->i_mapping->a_ops = &logfs_reg_aops; 65 break; 66 case S_IFLNK: 67 inode->i_op = &logfs_symlink_iops; 68 inode->i_mapping->a_ops = &logfs_reg_aops; 69 break; 70 case S_IFSOCK: /* fall through */ 71 case S_IFBLK: /* fall through */ 72 case S_IFCHR: /* fall through */ 73 case S_IFIFO: 74 init_special_inode(inode, inode->i_mode, inode->i_rdev); 75 break; 76 default: 77 BUG(); 78 } 79} 80 81static struct inode *__logfs_iget(struct super_block *sb, ino_t ino) 82{ 83 struct inode *inode = iget_locked(sb, ino); 84 int err; 85 86 if (!inode) 87 return ERR_PTR(-ENOMEM); 88 if (!(inode->i_state & I_NEW)) 89 return inode; 90 91 err = logfs_read_inode(inode); 92 if (err || inode->i_nlink == 0) { 93 /* inode->i_nlink == 0 can be true when called from 94 * block validator */ 95 /* set i_nlink to 0 to prevent caching */ 96 clear_nlink(inode); 97 logfs_inode(inode)->li_flags |= LOGFS_IF_ZOMBIE; 98 iget_failed(inode); 99 if (!err) 100 err = -ENOENT; 101 return ERR_PTR(err); 102 } 103 104 logfs_inode_setops(inode); 105 unlock_new_inode(inode); 106 return inode; 107} 108 109struct inode *logfs_iget(struct super_block *sb, ino_t ino) 110{ 111 BUG_ON(ino == LOGFS_INO_MASTER); 112 BUG_ON(ino == LOGFS_INO_SEGFILE); 113 return __logfs_iget(sb, ino); 114} 115 116/* 117 * is_cached is set to 1 if we hand out a cached inode, 0 otherwise. 118 * this allows logfs_iput to do the right thing later 119 */ 120struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *is_cached) 121{ 122 struct logfs_super *super = logfs_super(sb); 123 struct logfs_inode *li; 124 125 if (ino == LOGFS_INO_MASTER) 126 return super->s_master_inode; 127 if (ino == LOGFS_INO_SEGFILE) 128 return super->s_segfile_inode; 129 130 spin_lock(&logfs_inode_lock); 131 list_for_each_entry(li, &super->s_freeing_list, li_freeing_list) 132 if (li->vfs_inode.i_ino == ino) { 133 li->li_refcount++; 134 spin_unlock(&logfs_inode_lock); 135 *is_cached = 1; 136 return &li->vfs_inode; 137 } 138 spin_unlock(&logfs_inode_lock); 139 140 *is_cached = 0; 141 return __logfs_iget(sb, ino); 142} 143 144static void logfs_i_callback(struct rcu_head *head) 145{ 146 struct inode *inode = container_of(head, struct inode, i_rcu); 147 kmem_cache_free(logfs_inode_cache, logfs_inode(inode)); 148} 149 150static void __logfs_destroy_inode(struct inode *inode) 151{ 152 struct logfs_inode *li = logfs_inode(inode); 153 154 BUG_ON(li->li_block); 155 list_del(&li->li_freeing_list); 156 call_rcu(&inode->i_rcu, logfs_i_callback); 157} 158 159static void __logfs_destroy_meta_inode(struct inode *inode) 160{ 161 struct logfs_inode *li = logfs_inode(inode); 162 BUG_ON(li->li_block); 163 call_rcu(&inode->i_rcu, logfs_i_callback); 164} 165 166static void logfs_destroy_inode(struct inode *inode) 167{ 168 struct logfs_inode *li = logfs_inode(inode); 169 170 if (inode->i_ino < LOGFS_RESERVED_INOS) { 171 /* 172 * The reserved inodes are never destroyed unless we are in 173 * unmont path. 174 */ 175 __logfs_destroy_meta_inode(inode); 176 return; 177 } 178 179 BUG_ON(list_empty(&li->li_freeing_list)); 180 spin_lock(&logfs_inode_lock); 181 li->li_refcount--; 182 if (li->li_refcount == 0) 183 __logfs_destroy_inode(inode); 184 spin_unlock(&logfs_inode_lock); 185} 186 187void logfs_safe_iput(struct inode *inode, int is_cached) 188{ 189 if (inode->i_ino == LOGFS_INO_MASTER) 190 return; 191 if (inode->i_ino == LOGFS_INO_SEGFILE) 192 return; 193 194 if (is_cached) { 195 logfs_destroy_inode(inode); 196 return; 197 } 198 199 iput(inode); 200} 201 202static void logfs_init_inode(struct super_block *sb, struct inode *inode) 203{ 204 struct logfs_inode *li = logfs_inode(inode); 205 int i; 206 207 li->li_flags = 0; 208 li->li_height = 0; 209 li->li_used_bytes = 0; 210 li->li_block = NULL; 211 i_uid_write(inode, 0); 212 i_gid_write(inode, 0); 213 inode->i_size = 0; 214 inode->i_blocks = 0; 215 inode->i_ctime = CURRENT_TIME; 216 inode->i_mtime = CURRENT_TIME; 217 li->li_refcount = 1; 218 INIT_LIST_HEAD(&li->li_freeing_list); 219 220 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++) 221 li->li_data[i] = 0; 222 223 return; 224} 225 226static struct inode *logfs_alloc_inode(struct super_block *sb) 227{ 228 struct logfs_inode *li; 229 230 li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS); 231 if (!li) 232 return NULL; 233 logfs_init_inode(sb, &li->vfs_inode); 234 return &li->vfs_inode; 235} 236 237/* 238 * In logfs inodes are written to an inode file. The inode file, like any 239 * other file, is managed with a inode. The inode file's inode, aka master 240 * inode, requires special handling in several respects. First, it cannot be 241 * written to the inode file, so it is stored in the journal instead. 242 * 243 * Secondly, this inode cannot be written back and destroyed before all other 244 * inodes have been written. The ordering is important. Linux' VFS is happily 245 * unaware of the ordering constraint and would ordinarily destroy the master 246 * inode at umount time while other inodes are still in use and dirty. Not 247 * good. 248 * 249 * So logfs makes sure the master inode is not written until all other inodes 250 * have been destroyed. Sadly, this method has another side-effect. The VFS 251 * will notice one remaining inode and print a frightening warning message. 252 * Worse, it is impossible to judge whether such a warning was caused by the 253 * master inode or any other inodes have leaked as well. 254 * 255 * Our attempt of solving this is with logfs_new_meta_inode() below. Its 256 * purpose is to create a new inode that will not trigger the warning if such 257 * an inode is still in use. An ugly hack, no doubt. Suggections for 258 * improvement are welcome. 259 * 260 * AV: that's what ->put_super() is for... 261 */ 262struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino) 263{ 264 struct inode *inode; 265 266 inode = new_inode(sb); 267 if (!inode) 268 return ERR_PTR(-ENOMEM); 269 270 inode->i_mode = S_IFREG; 271 inode->i_ino = ino; 272 inode->i_data.a_ops = &logfs_reg_aops; 273 mapping_set_gfp_mask(&inode->i_data, GFP_NOFS); 274 275 return inode; 276} 277 278struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino) 279{ 280 struct inode *inode; 281 int err; 282 283 inode = logfs_new_meta_inode(sb, ino); 284 if (IS_ERR(inode)) 285 return inode; 286 287 err = logfs_read_inode(inode); 288 if (err) { 289 iput(inode); 290 return ERR_PTR(err); 291 } 292 logfs_inode_setops(inode); 293 return inode; 294} 295 296static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc) 297{ 298 int ret; 299 long flags = WF_LOCK; 300 301 /* Can only happen if creat() failed. Safe to skip. */ 302 if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN) 303 return 0; 304 305 ret = __logfs_write_inode(inode, NULL, flags); 306 LOGFS_BUG_ON(ret, inode->i_sb); 307 return ret; 308} 309 310/* called with inode->i_lock held */ 311static int logfs_drop_inode(struct inode *inode) 312{ 313 struct logfs_super *super = logfs_super(inode->i_sb); 314 struct logfs_inode *li = logfs_inode(inode); 315 316 spin_lock(&logfs_inode_lock); 317 list_move(&li->li_freeing_list, &super->s_freeing_list); 318 spin_unlock(&logfs_inode_lock); 319 return generic_drop_inode(inode); 320} 321 322static void logfs_set_ino_generation(struct super_block *sb, 323 struct inode *inode) 324{ 325 struct logfs_super *super = logfs_super(sb); 326 u64 ino; 327 328 mutex_lock(&super->s_journal_mutex); 329 ino = logfs_seek_hole(super->s_master_inode, super->s_last_ino + 1); 330 super->s_last_ino = ino; 331 super->s_inos_till_wrap--; 332 if (super->s_inos_till_wrap < 0) { 333 super->s_last_ino = LOGFS_RESERVED_INOS; 334 super->s_generation++; 335 super->s_inos_till_wrap = INOS_PER_WRAP; 336 } 337 inode->i_ino = ino; 338 inode->i_generation = super->s_generation; 339 mutex_unlock(&super->s_journal_mutex); 340} 341 342struct inode *logfs_new_inode(struct inode *dir, umode_t mode) 343{ 344 struct super_block *sb = dir->i_sb; 345 struct inode *inode; 346 347 inode = new_inode(sb); 348 if (!inode) 349 return ERR_PTR(-ENOMEM); 350 351 logfs_init_inode(sb, inode); 352 353 /* inherit parent flags */ 354 logfs_inode(inode)->li_flags |= 355 logfs_inode(dir)->li_flags & LOGFS_FL_INHERITED; 356 357 inode->i_mode = mode; 358 logfs_set_ino_generation(sb, inode); 359 360 inode_init_owner(inode, dir, mode); 361 logfs_inode_setops(inode); 362 insert_inode_hash(inode); 363 364 return inode; 365} 366 367static void logfs_init_once(void *_li) 368{ 369 struct logfs_inode *li = _li; 370 int i; 371 372 li->li_flags = 0; 373 li->li_used_bytes = 0; 374 li->li_refcount = 1; 375 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++) 376 li->li_data[i] = 0; 377 inode_init_once(&li->vfs_inode); 378} 379 380static int logfs_sync_fs(struct super_block *sb, int wait) 381{ 382 logfs_get_wblocks(sb, NULL, WF_LOCK); 383 logfs_write_anchor(sb); 384 logfs_put_wblocks(sb, NULL, WF_LOCK); 385 return 0; 386} 387 388static void logfs_put_super(struct super_block *sb) 389{ 390 struct logfs_super *super = logfs_super(sb); 391 /* kill the meta-inodes */ 392 iput(super->s_segfile_inode); 393 iput(super->s_master_inode); 394 iput(super->s_mapping_inode); 395} 396 397const struct super_operations logfs_super_operations = { 398 .alloc_inode = logfs_alloc_inode, 399 .destroy_inode = logfs_destroy_inode, 400 .evict_inode = logfs_evict_inode, 401 .drop_inode = logfs_drop_inode, 402 .put_super = logfs_put_super, 403 .write_inode = logfs_write_inode, 404 .statfs = logfs_statfs, 405 .sync_fs = logfs_sync_fs, 406}; 407 408int logfs_init_inode_cache(void) 409{ 410 logfs_inode_cache = kmem_cache_create("logfs_inode_cache", 411 sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT, 412 logfs_init_once); 413 if (!logfs_inode_cache) 414 return -ENOMEM; 415 return 0; 416} 417 418void logfs_destroy_inode_cache(void) 419{ 420 /* 421 * Make sure all delayed rcu free inodes are flushed before we 422 * destroy cache. 423 */ 424 rcu_barrier(); 425 kmem_cache_destroy(logfs_inode_cache); 426} 427