2 * fs/logfs/inode.c - inode handling code
4 * As should be obvious for Linux kernel code, license is GPLv2
6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
9 #include <linux/slab.h>
10 #include <linux/writeback.h>
11 #include <linux/backing-dev.h>
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...
26 * NFS sucks, as everyone already knows.
28 #define INOS_PER_WRAP (0x10000)
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.
35 * So we cannot just call iget() or some variant of it, but first have to check
36 * wether 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.
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.
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
49 static struct kmem_cache
*logfs_inode_cache
;
51 static DEFINE_SPINLOCK(logfs_inode_lock
);
53 static void logfs_inode_setops(struct inode
*inode
)
55 switch (inode
->i_mode
& S_IFMT
) {
57 inode
->i_op
= &logfs_dir_iops
;
58 inode
->i_fop
= &logfs_dir_fops
;
59 inode
->i_mapping
->a_ops
= &logfs_reg_aops
;
62 inode
->i_op
= &logfs_reg_iops
;
63 inode
->i_fop
= &logfs_reg_fops
;
64 inode
->i_mapping
->a_ops
= &logfs_reg_aops
;
67 inode
->i_op
= &logfs_symlink_iops
;
68 inode
->i_mapping
->a_ops
= &logfs_reg_aops
;
70 case S_IFSOCK
: /* fall through */
71 case S_IFBLK
: /* fall through */
72 case S_IFCHR
: /* fall through */
74 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
81 static struct inode
*__logfs_iget(struct super_block
*sb
, ino_t ino
)
83 struct inode
*inode
= iget_locked(sb
, ino
);
87 return ERR_PTR(-ENOMEM
);
88 if (!(inode
->i_state
& I_NEW
))
91 err
= logfs_read_inode(inode
);
92 if (err
|| inode
->i_nlink
== 0) {
93 /* inode->i_nlink == 0 can be true when called from
95 /* set i_nlink to 0 to prevent caching */
97 logfs_inode(inode
)->li_flags
|= LOGFS_IF_ZOMBIE
;
104 logfs_inode_setops(inode
);
105 unlock_new_inode(inode
);
109 struct inode
*logfs_iget(struct super_block
*sb
, ino_t ino
)
111 BUG_ON(ino
== LOGFS_INO_MASTER
);
112 BUG_ON(ino
== LOGFS_INO_SEGFILE
);
113 return __logfs_iget(sb
, ino
);
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
120 struct inode
*logfs_safe_iget(struct super_block
*sb
, ino_t ino
, int *is_cached
)
122 struct logfs_super
*super
= logfs_super(sb
);
123 struct logfs_inode
*li
;
125 if (ino
== LOGFS_INO_MASTER
)
126 return super
->s_master_inode
;
127 if (ino
== LOGFS_INO_SEGFILE
)
128 return super
->s_segfile_inode
;
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
) {
134 spin_unlock(&logfs_inode_lock
);
136 return &li
->vfs_inode
;
138 spin_unlock(&logfs_inode_lock
);
141 return __logfs_iget(sb
, ino
);
144 static void __logfs_destroy_inode(struct inode
*inode
)
146 struct logfs_inode
*li
= logfs_inode(inode
);
148 BUG_ON(li
->li_block
);
149 list_del(&li
->li_freeing_list
);
150 kmem_cache_free(logfs_inode_cache
, li
);
153 static void logfs_destroy_inode(struct inode
*inode
)
155 struct logfs_inode
*li
= logfs_inode(inode
);
157 BUG_ON(list_empty(&li
->li_freeing_list
));
158 spin_lock(&logfs_inode_lock
);
160 if (li
->li_refcount
== 0)
161 __logfs_destroy_inode(inode
);
162 spin_unlock(&logfs_inode_lock
);
165 void logfs_safe_iput(struct inode
*inode
, int is_cached
)
167 if (inode
->i_ino
== LOGFS_INO_MASTER
)
169 if (inode
->i_ino
== LOGFS_INO_SEGFILE
)
173 logfs_destroy_inode(inode
);
180 static void logfs_init_inode(struct super_block
*sb
, struct inode
*inode
)
182 struct logfs_inode
*li
= logfs_inode(inode
);
187 li
->li_used_bytes
= 0;
193 inode
->i_ctime
= CURRENT_TIME
;
194 inode
->i_mtime
= CURRENT_TIME
;
196 INIT_LIST_HEAD(&li
->li_freeing_list
);
198 for (i
= 0; i
< LOGFS_EMBEDDED_FIELDS
; i
++)
204 static struct inode
*logfs_alloc_inode(struct super_block
*sb
)
206 struct logfs_inode
*li
;
208 li
= kmem_cache_alloc(logfs_inode_cache
, GFP_NOFS
);
211 logfs_init_inode(sb
, &li
->vfs_inode
);
212 return &li
->vfs_inode
;
216 * In logfs inodes are written to an inode file. The inode file, like any
217 * other file, is managed with a inode. The inode file's inode, aka master
218 * inode, requires special handling in several respects. First, it cannot be
219 * written to the inode file, so it is stored in the journal instead.
221 * Secondly, this inode cannot be written back and destroyed before all other
222 * inodes have been written. The ordering is important. Linux' VFS is happily
223 * unaware of the ordering constraint and would ordinarily destroy the master
224 * inode at umount time while other inodes are still in use and dirty. Not
227 * So logfs makes sure the master inode is not written until all other inodes
228 * have been destroyed. Sadly, this method has another side-effect. The VFS
229 * will notice one remaining inode and print a frightening warning message.
230 * Worse, it is impossible to judge whether such a warning was caused by the
231 * master inode or any other inodes have leaked as well.
233 * Our attempt of solving this is with logfs_new_meta_inode() below. Its
234 * purpose is to create a new inode that will not trigger the warning if such
235 * an inode is still in use. An ugly hack, no doubt. Suggections for
236 * improvement are welcome.
238 struct inode
*logfs_new_meta_inode(struct super_block
*sb
, u64 ino
)
242 inode
= logfs_alloc_inode(sb
);
244 return ERR_PTR(-ENOMEM
);
246 inode
->i_mode
= S_IFREG
;
250 /* This is a blatant copy of alloc_inode code. We'd need alloc_inode
251 * to be nonstatic, alas. */
253 struct address_space
* const mapping
= &inode
->i_data
;
255 mapping
->a_ops
= &logfs_reg_aops
;
256 mapping
->host
= inode
;
258 mapping_set_gfp_mask(mapping
, GFP_NOFS
);
259 mapping
->assoc_mapping
= NULL
;
260 mapping
->backing_dev_info
= &default_backing_dev_info
;
261 inode
->i_mapping
= mapping
;
268 struct inode
*logfs_read_meta_inode(struct super_block
*sb
, u64 ino
)
273 inode
= logfs_new_meta_inode(sb
, ino
);
277 err
= logfs_read_inode(inode
);
279 destroy_meta_inode(inode
);
282 logfs_inode_setops(inode
);
286 static int logfs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
289 long flags
= WF_LOCK
;
291 /* Can only happen if creat() failed. Safe to skip. */
292 if (logfs_inode(inode
)->li_flags
& LOGFS_IF_STILLBORN
)
295 ret
= __logfs_write_inode(inode
, flags
);
296 LOGFS_BUG_ON(ret
, inode
->i_sb
);
300 void destroy_meta_inode(struct inode
*inode
)
303 if (inode
->i_data
.nrpages
)
304 truncate_inode_pages(&inode
->i_data
, 0);
305 logfs_clear_inode(inode
);
306 kmem_cache_free(logfs_inode_cache
, logfs_inode(inode
));
310 /* called with inode_lock held */
311 static void logfs_drop_inode(struct inode
*inode
)
313 struct logfs_super
*super
= logfs_super(inode
->i_sb
);
314 struct logfs_inode
*li
= logfs_inode(inode
);
316 spin_lock(&logfs_inode_lock
);
317 list_move(&li
->li_freeing_list
, &super
->s_freeing_list
);
318 spin_unlock(&logfs_inode_lock
);
319 generic_drop_inode(inode
);
322 static void logfs_set_ino_generation(struct super_block
*sb
,
325 struct logfs_super
*super
= logfs_super(sb
);
328 mutex_lock(&super
->s_journal_mutex
);
329 ino
= logfs_seek_hole(super
->s_master_inode
, super
->s_last_ino
);
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
;
338 inode
->i_generation
= super
->s_generation
;
339 mutex_unlock(&super
->s_journal_mutex
);
342 struct inode
*logfs_new_inode(struct inode
*dir
, int mode
)
344 struct super_block
*sb
= dir
->i_sb
;
347 inode
= new_inode(sb
);
349 return ERR_PTR(-ENOMEM
);
351 logfs_init_inode(sb
, inode
);
353 /* inherit parent flags */
354 logfs_inode(inode
)->li_flags
|=
355 logfs_inode(dir
)->li_flags
& LOGFS_FL_INHERITED
;
357 inode
->i_mode
= mode
;
358 logfs_set_ino_generation(sb
, inode
);
360 inode
->i_uid
= current_fsuid();
361 inode
->i_gid
= current_fsgid();
362 if (dir
->i_mode
& S_ISGID
) {
363 inode
->i_gid
= dir
->i_gid
;
365 inode
->i_mode
|= S_ISGID
;
368 logfs_inode_setops(inode
);
369 insert_inode_hash(inode
);
374 static void logfs_init_once(void *_li
)
376 struct logfs_inode
*li
= _li
;
380 li
->li_used_bytes
= 0;
382 for (i
= 0; i
< LOGFS_EMBEDDED_FIELDS
; i
++)
384 inode_init_once(&li
->vfs_inode
);
387 static int logfs_sync_fs(struct super_block
*sb
, int wait
)
389 /* FIXME: write anchor */
390 logfs_super(sb
)->s_devops
->sync(sb
);
394 const struct super_operations logfs_super_operations
= {
395 .alloc_inode
= logfs_alloc_inode
,
396 .clear_inode
= logfs_clear_inode
,
397 .delete_inode
= logfs_delete_inode
,
398 .destroy_inode
= logfs_destroy_inode
,
399 .drop_inode
= logfs_drop_inode
,
400 .write_inode
= logfs_write_inode
,
401 .statfs
= logfs_statfs
,
402 .sync_fs
= logfs_sync_fs
,
405 int logfs_init_inode_cache(void)
407 logfs_inode_cache
= kmem_cache_create("logfs_inode_cache",
408 sizeof(struct logfs_inode
), 0, SLAB_RECLAIM_ACCOUNT
,
410 if (!logfs_inode_cache
)
415 void logfs_destroy_inode_cache(void)
417 kmem_cache_destroy(logfs_inode_cache
);