~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/logfs/inode.c

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  * 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  */
 49 static struct kmem_cache *logfs_inode_cache;
 50 
 51 static DEFINE_SPINLOCK(logfs_inode_lock);
 52 
 53 static 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 
 81 static 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 
109 struct 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  */
120 struct 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 
144 static void logfs_i_callback(struct rcu_head *head)
145 {
146         struct inode *inode = container_of(head, struct inode, i_rcu);
147         INIT_LIST_HEAD(&inode->i_dentry);
148         kmem_cache_free(logfs_inode_cache, logfs_inode(inode));
149 }
150 
151 static void __logfs_destroy_inode(struct inode *inode)
152 {
153         struct logfs_inode *li = logfs_inode(inode);
154 
155         BUG_ON(li->li_block);
156         list_del(&li->li_freeing_list);
157         call_rcu(&inode->i_rcu, logfs_i_callback);
158 }
159 
160 static void logfs_destroy_inode(struct inode *inode)
161 {
162         struct logfs_inode *li = logfs_inode(inode);
163 
164         BUG_ON(list_empty(&li->li_freeing_list));
165         spin_lock(&logfs_inode_lock);
166         li->li_refcount--;
167         if (li->li_refcount == 0)
168                 __logfs_destroy_inode(inode);
169         spin_unlock(&logfs_inode_lock);
170 }
171 
172 void logfs_safe_iput(struct inode *inode, int is_cached)
173 {
174         if (inode->i_ino == LOGFS_INO_MASTER)
175                 return;
176         if (inode->i_ino == LOGFS_INO_SEGFILE)
177                 return;
178 
179         if (is_cached) {
180                 logfs_destroy_inode(inode);
181                 return;
182         }
183 
184         iput(inode);
185 }
186 
187 static void logfs_init_inode(struct super_block *sb, struct inode *inode)
188 {
189         struct logfs_inode *li = logfs_inode(inode);
190         int i;
191 
192         li->li_flags    = 0;
193         li->li_height   = 0;
194         li->li_used_bytes = 0;
195         li->li_block    = NULL;
196         inode->i_uid    = 0;
197         inode->i_gid    = 0;
198         inode->i_size   = 0;
199         inode->i_blocks = 0;
200         inode->i_ctime  = CURRENT_TIME;
201         inode->i_mtime  = CURRENT_TIME;
202         li->li_refcount = 1;
203         INIT_LIST_HEAD(&li->li_freeing_list);
204 
205         for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
206                 li->li_data[i] = 0;
207 
208         return;
209 }
210 
211 static struct inode *logfs_alloc_inode(struct super_block *sb)
212 {
213         struct logfs_inode *li;
214 
215         li = kmem_cache_alloc(logfs_inode_cache, GFP_NOFS);
216         if (!li)
217                 return NULL;
218         logfs_init_inode(sb, &li->vfs_inode);
219         return &li->vfs_inode;
220 }
221 
222 /*
223  * In logfs inodes are written to an inode file.  The inode file, like any
224  * other file, is managed with a inode.  The inode file's inode, aka master
225  * inode, requires special handling in several respects.  First, it cannot be
226  * written to the inode file, so it is stored in the journal instead.
227  *
228  * Secondly, this inode cannot be written back and destroyed before all other
229  * inodes have been written.  The ordering is important.  Linux' VFS is happily
230  * unaware of the ordering constraint and would ordinarily destroy the master
231  * inode at umount time while other inodes are still in use and dirty.  Not
232  * good.
233  *
234  * So logfs makes sure the master inode is not written until all other inodes
235  * have been destroyed.  Sadly, this method has another side-effect.  The VFS
236  * will notice one remaining inode and print a frightening warning message.
237  * Worse, it is impossible to judge whether such a warning was caused by the
238  * master inode or any other inodes have leaked as well.
239  *
240  * Our attempt of solving this is with logfs_new_meta_inode() below.  Its
241  * purpose is to create a new inode that will not trigger the warning if such
242  * an inode is still in use.  An ugly hack, no doubt.  Suggections for
243  * improvement are welcome.
244  *
245  * AV: that's what ->put_super() is for...
246  */
247 struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino)
248 {
249         struct inode *inode;
250 
251         inode = new_inode(sb);
252         if (!inode)
253                 return ERR_PTR(-ENOMEM);
254 
255         inode->i_mode = S_IFREG;
256         inode->i_ino = ino;
257         inode->i_data.a_ops = &logfs_reg_aops;
258         mapping_set_gfp_mask(&inode->i_data, GFP_NOFS);
259 
260         return inode;
261 }
262 
263 struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino)
264 {
265         struct inode *inode;
266         int err;
267 
268         inode = logfs_new_meta_inode(sb, ino);
269         if (IS_ERR(inode))
270                 return inode;
271 
272         err = logfs_read_inode(inode);
273         if (err) {
274                 iput(inode);
275                 return ERR_PTR(err);
276         }
277         logfs_inode_setops(inode);
278         return inode;
279 }
280 
281 static int logfs_write_inode(struct inode *inode, struct writeback_control *wbc)
282 {
283         int ret;
284         long flags = WF_LOCK;
285 
286         /* Can only happen if creat() failed.  Safe to skip. */
287         if (logfs_inode(inode)->li_flags & LOGFS_IF_STILLBORN)
288                 return 0;
289 
290         ret = __logfs_write_inode(inode, flags);
291         LOGFS_BUG_ON(ret, inode->i_sb);
292         return ret;
293 }
294 
295 /* called with inode->i_lock held */
296 static int logfs_drop_inode(struct inode *inode)
297 {
298         struct logfs_super *super = logfs_super(inode->i_sb);
299         struct logfs_inode *li = logfs_inode(inode);
300 
301         spin_lock(&logfs_inode_lock);
302         list_move(&li->li_freeing_list, &super->s_freeing_list);
303         spin_unlock(&logfs_inode_lock);
304         return generic_drop_inode(inode);
305 }
306 
307 static void logfs_set_ino_generation(struct super_block *sb,
308                 struct inode *inode)
309 {
310         struct logfs_super *super = logfs_super(sb);
311         u64 ino;
312 
313         mutex_lock(&super->s_journal_mutex);
314         ino = logfs_seek_hole(super->s_master_inode, super->s_last_ino + 1);
315         super->s_last_ino = ino;
316         super->s_inos_till_wrap--;
317         if (super->s_inos_till_wrap < 0) {
318                 super->s_last_ino = LOGFS_RESERVED_INOS;
319                 super->s_generation++;
320                 super->s_inos_till_wrap = INOS_PER_WRAP;
321         }
322         inode->i_ino = ino;
323         inode->i_generation = super->s_generation;
324         mutex_unlock(&super->s_journal_mutex);
325 }
326 
327 struct inode *logfs_new_inode(struct inode *dir, int mode)
328 {
329         struct super_block *sb = dir->i_sb;
330         struct inode *inode;
331 
332         inode = new_inode(sb);
333         if (!inode)
334                 return ERR_PTR(-ENOMEM);
335 
336         logfs_init_inode(sb, inode);
337 
338         /* inherit parent flags */
339         logfs_inode(inode)->li_flags |=
340                 logfs_inode(dir)->li_flags & LOGFS_FL_INHERITED;
341 
342         inode->i_mode = mode;
343         logfs_set_ino_generation(sb, inode);
344 
345         inode_init_owner(inode, dir, mode);
346         logfs_inode_setops(inode);
347         insert_inode_hash(inode);
348 
349         return inode;
350 }
351 
352 static void logfs_init_once(void *_li)
353 {
354         struct logfs_inode *li = _li;
355         int i;
356 
357         li->li_flags = 0;
358         li->li_used_bytes = 0;
359         li->li_refcount = 1;
360         for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
361                 li->li_data[i] = 0;
362         inode_init_once(&li->vfs_inode);
363 }
364 
365 static int logfs_sync_fs(struct super_block *sb, int wait)
366 {
367         logfs_write_anchor(sb);
368         return 0;
369 }
370 
371 static void logfs_put_super(struct super_block *sb)
372 {
373         struct logfs_super *super = logfs_super(sb);
374         /* kill the meta-inodes */
375         iput(super->s_master_inode);
376         iput(super->s_segfile_inode);
377         iput(super->s_mapping_inode);
378 }
379 
380 const struct super_operations logfs_super_operations = {
381         .alloc_inode    = logfs_alloc_inode,
382         .destroy_inode  = logfs_destroy_inode,
383         .evict_inode    = logfs_evict_inode,
384         .drop_inode     = logfs_drop_inode,
385         .put_super      = logfs_put_super,
386         .write_inode    = logfs_write_inode,
387         .statfs         = logfs_statfs,
388         .sync_fs        = logfs_sync_fs,
389 };
390 
391 int logfs_init_inode_cache(void)
392 {
393         logfs_inode_cache = kmem_cache_create("logfs_inode_cache",
394                         sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT,
395                         logfs_init_once);
396         if (!logfs_inode_cache)
397                 return -ENOMEM;
398         return 0;
399 }
400 
401 void logfs_destroy_inode_cache(void)
402 {
403         kmem_cache_destroy(logfs_inode_cache);
404 }
405 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp