blob: d8c71ece098fb2d5ce87afe1fbb16a1fc130d336 [file] [log] [blame]
Joern Engel5db53f32009-11-20 20:13:39 +01001/*
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"
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09009#include <linux/slab.h>
Joern Engel5db53f32009-11-20 20:13:39 +010010#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 * 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.
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 inode->i_nlink = 0;
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_destroy_inode(struct inode *inode)
145{
146 struct logfs_inode *li = logfs_inode(inode);
147
148 BUG_ON(li->li_block);
149 list_del(&li->li_freeing_list);
150 kmem_cache_free(logfs_inode_cache, li);
151}
152
153static void logfs_destroy_inode(struct inode *inode)
154{
155 struct logfs_inode *li = logfs_inode(inode);
156
157 BUG_ON(list_empty(&li->li_freeing_list));
158 spin_lock(&logfs_inode_lock);
159 li->li_refcount--;
160 if (li->li_refcount == 0)
161 __logfs_destroy_inode(inode);
162 spin_unlock(&logfs_inode_lock);
163}
164
165void logfs_safe_iput(struct inode *inode, int is_cached)
166{
167 if (inode->i_ino == LOGFS_INO_MASTER)
168 return;
169 if (inode->i_ino == LOGFS_INO_SEGFILE)
170 return;
171
172 if (is_cached) {
173 logfs_destroy_inode(inode);
174 return;
175 }
176
177 iput(inode);
178}
179
180static void logfs_init_inode(struct super_block *sb, struct inode *inode)
181{
182 struct logfs_inode *li = logfs_inode(inode);
183 int i;
184
185 li->li_flags = 0;
186 li->li_height = 0;
187 li->li_used_bytes = 0;
188 li->li_block = NULL;
189 inode->i_uid = 0;
190 inode->i_gid = 0;
191 inode->i_size = 0;
192 inode->i_blocks = 0;
193 inode->i_ctime = CURRENT_TIME;
194 inode->i_mtime = CURRENT_TIME;
195 inode->i_nlink = 1;
Prasad Joshi24797532010-05-04 22:13:59 +0200196 li->li_refcount = 1;
Joern Engel5db53f32009-11-20 20:13:39 +0100197 INIT_LIST_HEAD(&li->li_freeing_list);
198
199 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
200 li->li_data[i] = 0;
201
202 return;
203}
204
205static struct inode *logfs_alloc_inode(struct super_block *sb)
206{
207 struct logfs_inode *li;
208
209 li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS);
210 if (!li)
211 return NULL;
212 logfs_init_inode(sb, &li->vfs_inode);
213 return &li->vfs_inode;
214}
215
216/*
217 * In logfs inodes are written to an inode file. The inode file, like any
218 * other file, is managed with a inode. The inode file's inode, aka master
219 * inode, requires special handling in several respects. First, it cannot be
220 * written to the inode file, so it is stored in the journal instead.
221 *
222 * Secondly, this inode cannot be written back and destroyed before all other
223 * inodes have been written. The ordering is important. Linux' VFS is happily
224 * unaware of the ordering constraint and would ordinarily destroy the master
225 * inode at umount time while other inodes are still in use and dirty. Not
226 * good.
227 *
228 * So logfs makes sure the master inode is not written until all other inodes
229 * have been destroyed. Sadly, this method has another side-effect. The VFS
230 * will notice one remaining inode and print a frightening warning message.
231 * Worse, it is impossible to judge whether such a warning was caused by the
232 * master inode or any other inodes have leaked as well.
233 *
234 * Our attempt of solving this is with logfs_new_meta_inode() below. Its
235 * purpose is to create a new inode that will not trigger the warning if such
236 * an inode is still in use. An ugly hack, no doubt. Suggections for
237 * improvement are welcome.
Al Viro8e22c1a2010-06-07 12:22:31 -0400238 *
239 * AV: that's what ->put_super() is for...
Joern Engel5db53f32009-11-20 20:13:39 +0100240 */
241struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino)
242{
243 struct inode *inode;
244
Al Viro8e22c1a2010-06-07 12:22:31 -0400245 inode = new_inode(sb);
Joern Engel5db53f32009-11-20 20:13:39 +0100246 if (!inode)
247 return ERR_PTR(-ENOMEM);
248
249 inode->i_mode = S_IFREG;
250 inode->i_ino = ino;
Al Viro8e22c1a2010-06-07 12:22:31 -0400251 inode->i_data.a_ops = &logfs_reg_aops;
252 mapping_set_gfp_mask(&inode->i_data, GFP_NOFS);
Joern Engel5db53f32009-11-20 20:13:39 +0100253
254 return inode;
255}
256
257struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino)
258{
259 struct inode *inode;
260 int err;
261
262 inode = logfs_new_meta_inode(sb, ino);
263 if (IS_ERR(inode))
264 return inode;
265
266 err = logfs_read_inode(inode);
267 if (err) {
Al Viro8e22c1a2010-06-07 12:22:31 -0400268 iput(inode);
Joern Engel5db53f32009-11-20 20:13:39 +0100269 return ERR_PTR(err);
270 }
271 logfs_inode_setops(inode);
272 return inode;
273}
274
Linus Torvalds66b89152010-03-06 13:18:03 -0800275static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)
Joern Engel5db53f32009-11-20 20:13:39 +0100276{
277 int ret;
278 long flags = WF_LOCK;
279
280 /* Can only happen if creat() failed. Safe to skip. */
281 if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN)
282 return 0;
283
284 ret = __logfs_write_inode(inode, flags);
285 LOGFS_BUG_ON(ret, inode->i_sb);
286 return ret;
287}
288
Joern Engel5db53f32009-11-20 20:13:39 +0100289/* called with inode_lock held */
Al Viro45321ac2010-06-07 13:43:19 -0400290static int logfs_drop_inode(struct inode *inode)
Joern Engel5db53f32009-11-20 20:13:39 +0100291{
292 struct logfs_super *super = logfs_super(inode->i_sb);
293 struct logfs_inode *li = logfs_inode(inode);
294
295 spin_lock(&logfs_inode_lock);
296 list_move(&li->li_freeing_list, &super->s_freeing_list);
297 spin_unlock(&logfs_inode_lock);
Al Viro45321ac2010-06-07 13:43:19 -0400298 return generic_drop_inode(inode);
Joern Engel5db53f32009-11-20 20:13:39 +0100299}
300
301static void logfs_set_ino_generation(struct super_block *sb,
302 struct inode *inode)
303{
304 struct logfs_super *super = logfs_super(sb);
305 u64 ino;
306
307 mutex_lock(&super->s_journal_mutex);
Joern Engelccc01972010-05-01 17:00:34 +0200308 ino = logfs_seek_hole(super->s_master_inode, super->s_last_ino + 1);
Joern Engel5db53f32009-11-20 20:13:39 +0100309 super->s_last_ino = ino;
310 super->s_inos_till_wrap--;
311 if (super->s_inos_till_wrap < 0) {
312 super->s_last_ino = LOGFS_RESERVED_INOS;
313 super->s_generation++;
314 super->s_inos_till_wrap = INOS_PER_WRAP;
315 }
316 inode->i_ino = ino;
317 inode->i_generation = super->s_generation;
318 mutex_unlock(&super->s_journal_mutex);
319}
320
321struct inode *logfs_new_inode(struct inode *dir, int mode)
322{
323 struct super_block *sb = dir->i_sb;
324 struct inode *inode;
325
326 inode = new_inode(sb);
327 if (!inode)
328 return ERR_PTR(-ENOMEM);
329
330 logfs_init_inode(sb, inode);
331
332 /* inherit parent flags */
333 logfs_inode(inode)->li_flags |=
334 logfs_inode(dir)->li_flags & LOGFS_FL_INHERITED;
335
336 inode->i_mode = mode;
337 logfs_set_ino_generation(sb, inode);
338
Al Viroab9a79b2010-05-15 04:02:54 -0400339 inode_init_owner(inode, dir, mode);
Joern Engel5db53f32009-11-20 20:13:39 +0100340 logfs_inode_setops(inode);
341 insert_inode_hash(inode);
342
343 return inode;
344}
345
346static void logfs_init_once(void *_li)
347{
348 struct logfs_inode *li = _li;
349 int i;
350
351 li->li_flags = 0;
352 li->li_used_bytes = 0;
353 li->li_refcount = 1;
354 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
355 li->li_data[i] = 0;
356 inode_init_once(&li->vfs_inode);
357}
358
359static int logfs_sync_fs(struct super_block *sb, int wait)
360{
Joern Engelc0c79c32010-05-05 22:33:36 +0200361 logfs_write_anchor(sb);
Joern Engel5db53f32009-11-20 20:13:39 +0100362 return 0;
363}
364
Al Viro8e22c1a2010-06-07 12:22:31 -0400365static void logfs_put_super(struct super_block *sb)
366{
367 struct logfs_super *super = logfs_super(sb);
368 /* kill the meta-inodes */
369 iput(super->s_master_inode);
370 iput(super->s_segfile_inode);
371 iput(super->s_mapping_inode);
372}
373
Joern Engel5db53f32009-11-20 20:13:39 +0100374const struct super_operations logfs_super_operations = {
375 .alloc_inode = logfs_alloc_inode,
Joern Engel5db53f32009-11-20 20:13:39 +0100376 .destroy_inode = logfs_destroy_inode,
Al Viro7da08fd2010-06-07 13:11:34 -0400377 .evict_inode = logfs_evict_inode,
Joern Engel5db53f32009-11-20 20:13:39 +0100378 .drop_inode = logfs_drop_inode,
Al Viro8e22c1a2010-06-07 12:22:31 -0400379 .put_super = logfs_put_super,
Joern Engel5db53f32009-11-20 20:13:39 +0100380 .write_inode = logfs_write_inode,
381 .statfs = logfs_statfs,
382 .sync_fs = logfs_sync_fs,
383};
384
385int logfs_init_inode_cache(void)
386{
387 logfs_inode_cache = kmem_cache_create("logfs_inode_cache",
388 sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT,
389 logfs_init_once);
390 if (!logfs_inode_cache)
391 return -ENOMEM;
392 return 0;
393}
394
395void logfs_destroy_inode_cache(void)
396{
397 kmem_cache_destroy(logfs_inode_cache);
398}