inode.c 11 KB

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