Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dir.c
Go to the documentation of this file.
1 /*
2  * fs/logfs/dir.c - directory-related code
3  *
4  * As should be obvious for Linux kernel code, license is GPLv2
5  *
6  * Copyright (c) 2005-2008 Joern Engel <[email protected]>
7  */
8 #include "logfs.h"
9 #include <linux/slab.h>
10 
11 /*
12  * Atomic dir operations
13  *
14  * Directory operations are by default not atomic. Dentries and Inodes are
15  * created/removed/altered in separate operations. Therefore we need to do
16  * a small amount of journaling.
17  *
18  * Create, link, mkdir, mknod and symlink all share the same function to do
19  * the work: __logfs_create. This function works in two atomic steps:
20  * 1. allocate inode (remember in journal)
21  * 2. allocate dentry (clear journal)
22  *
23  * As we can only get interrupted between the two, when the inode we just
24  * created is simply stored in the anchor. On next mount, if we were
25  * interrupted, we delete the inode. From a users point of view the
26  * operation never happened.
27  *
28  * Unlink and rmdir also share the same function: unlink. Again, this
29  * function works in two atomic steps
30  * 1. remove dentry (remember inode in journal)
31  * 2. unlink inode (clear journal)
32  *
33  * And again, on the next mount, if we were interrupted, we delete the inode.
34  * From a users point of view the operation succeeded.
35  *
36  * Rename is the real pain to deal with, harder than all the other methods
37  * combined. Depending on the circumstances we can run into three cases.
38  * A "target rename" where the target dentry already existed, a "local
39  * rename" where both parent directories are identical or a "cross-directory
40  * rename" in the remaining case.
41  *
42  * Local rename is atomic, as the old dentry is simply rewritten with a new
43  * name.
44  *
45  * Cross-directory rename works in two steps, similar to __logfs_create and
46  * logfs_unlink:
47  * 1. Write new dentry (remember old dentry in journal)
48  * 2. Remove old dentry (clear journal)
49  *
50  * Here we remember a dentry instead of an inode. On next mount, if we were
51  * interrupted, we delete the dentry. From a users point of view, the
52  * operation succeeded.
53  *
54  * Target rename works in three atomic steps:
55  * 1. Attach old inode to new dentry (remember old dentry and new inode)
56  * 2. Remove old dentry (still remember the new inode)
57  * 3. Remove victim inode
58  *
59  * Here we remember both an inode an a dentry. If we get interrupted
60  * between steps 1 and 2, we delete both the dentry and the inode. If
61  * we get interrupted between steps 2 and 3, we delete just the inode.
62  * In either case, the remaining objects are deleted on next mount. From
63  * a users point of view, the operation succeeded.
64  */
65 
66 static int write_dir(struct inode *dir, struct logfs_disk_dentry *dd,
67  loff_t pos)
68 {
69  return logfs_inode_write(dir, dd, sizeof(*dd), pos, WF_LOCK, NULL);
70 }
71 
72 static int write_inode(struct inode *inode)
73 {
74  return __logfs_write_inode(inode, NULL, WF_LOCK);
75 }
76 
77 static s64 dir_seek_data(struct inode *inode, s64 pos)
78 {
79  s64 new_pos = logfs_seek_data(inode, pos);
80 
81  return max(pos, new_pos - 1);
82 }
83 
84 static int beyond_eof(struct inode *inode, loff_t bix)
85 {
86  loff_t pos = bix << inode->i_sb->s_blocksize_bits;
87  return pos >= i_size_read(inode);
88 }
89 
90 /*
91  * Prime value was chosen to be roughly 256 + 26. r5 hash uses 11,
92  * so short names (len <= 9) don't even occupy the complete 32bit name
93  * space. A prime >256 ensures short names quickly spread the 32bit
94  * name space. Add about 26 for the estimated amount of information
95  * of each character and pick a prime nearby, preferably a bit-sparse
96  * one.
97  */
98 static u32 hash_32(const char *s, int len, u32 seed)
99 {
100  u32 hash = seed;
101  int i;
102 
103  for (i = 0; i < len; i++)
104  hash = hash * 293 + s[i];
105  return hash;
106 }
107 
108 /*
109  * We have to satisfy several conflicting requirements here. Small
110  * directories should stay fairly compact and not require too many
111  * indirect blocks. The number of possible locations for a given hash
112  * should be small to make lookup() fast. And we should try hard not
113  * to overflow the 32bit name space or nfs and 32bit host systems will
114  * be unhappy.
115  *
116  * So we use the following scheme. First we reduce the hash to 0..15
117  * and try a direct block. If that is occupied we reduce the hash to
118  * 16..255 and try an indirect block. Same for 2x and 3x indirect
119  * blocks. Lastly we reduce the hash to 0x800_0000 .. 0xffff_ffff,
120  * but use buckets containing eight entries instead of a single one.
121  *
122  * Using 16 entries should allow for a reasonable amount of hash
123  * collisions, so the 32bit name space can be packed fairly tight
124  * before overflowing. Oh and currently we don't overflow but return
125  * and error.
126  *
127  * How likely are collisions? Doing the appropriate math is beyond me
128  * and the Bronstein textbook. But running a test program to brute
129  * force collisions for a couple of days showed that on average the
130  * first collision occurs after 598M entries, with 290M being the
131  * smallest result. Obviously 21 entries could already cause a
132  * collision if all entries are carefully chosen.
133  */
134 static pgoff_t hash_index(u32 hash, int round)
135 {
136  u32 i0_blocks = I0_BLOCKS;
137  u32 i1_blocks = I1_BLOCKS;
138  u32 i2_blocks = I2_BLOCKS;
139  u32 i3_blocks = I3_BLOCKS;
140 
141  switch (round) {
142  case 0:
143  return hash % i0_blocks;
144  case 1:
145  return i0_blocks + hash % (i1_blocks - i0_blocks);
146  case 2:
147  return i1_blocks + hash % (i2_blocks - i1_blocks);
148  case 3:
149  return i2_blocks + hash % (i3_blocks - i2_blocks);
150  case 4 ... 19:
151  return i3_blocks + 16 * (hash % (((1<<31) - i3_blocks) / 16))
152  + round - 4;
153  }
154  BUG();
155 }
156 
157 static struct page *logfs_get_dd_page(struct inode *dir, struct dentry *dentry)
158 {
159  struct qstr *name = &dentry->d_name;
160  struct page *page;
161  struct logfs_disk_dentry *dd;
162  u32 hash = hash_32(name->name, name->len, 0);
163  pgoff_t index;
164  int round;
165 
166  if (name->len > LOGFS_MAX_NAMELEN)
167  return ERR_PTR(-ENAMETOOLONG);
168 
169  for (round = 0; round < 20; round++) {
170  index = hash_index(hash, round);
171 
172  if (beyond_eof(dir, index))
173  return NULL;
174  if (!logfs_exist_block(dir, index))
175  continue;
176  page = read_cache_page(dir->i_mapping, index,
178  if (IS_ERR(page))
179  return page;
180  dd = kmap_atomic(page);
181  BUG_ON(dd->namelen == 0);
182 
183  if (name->len != be16_to_cpu(dd->namelen) ||
184  memcmp(name->name, dd->name, name->len)) {
185  kunmap_atomic(dd);
186  page_cache_release(page);
187  continue;
188  }
189 
190  kunmap_atomic(dd);
191  return page;
192  }
193  return NULL;
194 }
195 
196 static int logfs_remove_inode(struct inode *inode)
197 {
198  int ret;
199 
200  drop_nlink(inode);
201  ret = write_inode(inode);
202  LOGFS_BUG_ON(ret, inode->i_sb);
203  return ret;
204 }
205 
206 static void abort_transaction(struct inode *inode, struct logfs_transaction *ta)
207 {
208  if (logfs_inode(inode)->li_block)
209  logfs_inode(inode)->li_block->ta = NULL;
210  kfree(ta);
211 }
212 
213 static int logfs_unlink(struct inode *dir, struct dentry *dentry)
214 {
215  struct logfs_super *super = logfs_super(dir->i_sb);
216  struct inode *inode = dentry->d_inode;
217  struct logfs_transaction *ta;
218  struct page *page;
219  pgoff_t index;
220  int ret;
221 
222  ta = kzalloc(sizeof(*ta), GFP_KERNEL);
223  if (!ta)
224  return -ENOMEM;
225 
226  ta->state = UNLINK_1;
227  ta->ino = inode->i_ino;
228 
229  inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
230 
231  page = logfs_get_dd_page(dir, dentry);
232  if (!page) {
233  kfree(ta);
234  return -ENOENT;
235  }
236  if (IS_ERR(page)) {
237  kfree(ta);
238  return PTR_ERR(page);
239  }
240  index = page->index;
241  page_cache_release(page);
242 
243  mutex_lock(&super->s_dirop_mutex);
244  logfs_add_transaction(dir, ta);
245 
246  ret = logfs_delete(dir, index, NULL);
247  if (!ret)
248  ret = write_inode(dir);
249 
250  if (ret) {
251  abort_transaction(dir, ta);
252  printk(KERN_ERR"LOGFS: unable to delete inode\n");
253  goto out;
254  }
255 
256  ta->state = UNLINK_2;
257  logfs_add_transaction(inode, ta);
258  ret = logfs_remove_inode(inode);
259 out:
260  mutex_unlock(&super->s_dirop_mutex);
261  return ret;
262 }
263 
264 static inline int logfs_empty_dir(struct inode *dir)
265 {
266  u64 data;
267 
268  data = logfs_seek_data(dir, 0) << dir->i_sb->s_blocksize_bits;
269  return data >= i_size_read(dir);
270 }
271 
272 static int logfs_rmdir(struct inode *dir, struct dentry *dentry)
273 {
274  struct inode *inode = dentry->d_inode;
275 
276  if (!logfs_empty_dir(inode))
277  return -ENOTEMPTY;
278 
279  return logfs_unlink(dir, dentry);
280 }
281 
282 /* FIXME: readdir currently has it's own dir_walk code. I don't see a good
283  * way to combine the two copies */
284 #define IMPLICIT_NODES 2
285 static int __logfs_readdir(struct file *file, void *buf, filldir_t filldir)
286 {
287  struct inode *dir = file->f_dentry->d_inode;
288  loff_t pos = file->f_pos - IMPLICIT_NODES;
289  struct page *page;
290  struct logfs_disk_dentry *dd;
291  int full;
292 
293  BUG_ON(pos < 0);
294  for (;; pos++) {
295  if (beyond_eof(dir, pos))
296  break;
297  if (!logfs_exist_block(dir, pos)) {
298  /* deleted dentry */
299  pos = dir_seek_data(dir, pos);
300  continue;
301  }
302  page = read_cache_page(dir->i_mapping, pos,
304  if (IS_ERR(page))
305  return PTR_ERR(page);
306  dd = kmap(page);
307  BUG_ON(dd->namelen == 0);
308 
309  full = filldir(buf, (char *)dd->name, be16_to_cpu(dd->namelen),
310  pos, be64_to_cpu(dd->ino), dd->type);
311  kunmap(page);
312  page_cache_release(page);
313  if (full)
314  break;
315  }
316 
317  file->f_pos = pos + IMPLICIT_NODES;
318  return 0;
319 }
320 
321 static int logfs_readdir(struct file *file, void *buf, filldir_t filldir)
322 {
323  struct inode *inode = file->f_dentry->d_inode;
324  ino_t pino = parent_ino(file->f_dentry);
325  int err;
326 
327  if (file->f_pos < 0)
328  return -EINVAL;
329 
330  if (file->f_pos == 0) {
331  if (filldir(buf, ".", 1, 1, inode->i_ino, DT_DIR) < 0)
332  return 0;
333  file->f_pos++;
334  }
335  if (file->f_pos == 1) {
336  if (filldir(buf, "..", 2, 2, pino, DT_DIR) < 0)
337  return 0;
338  file->f_pos++;
339  }
340 
341  err = __logfs_readdir(file, buf, filldir);
342  return err;
343 }
344 
345 static void logfs_set_name(struct logfs_disk_dentry *dd, struct qstr *name)
346 {
347  dd->namelen = cpu_to_be16(name->len);
348  memcpy(dd->name, name->name, name->len);
349 }
350 
351 static struct dentry *logfs_lookup(struct inode *dir, struct dentry *dentry,
352  unsigned int flags)
353 {
354  struct page *page;
355  struct logfs_disk_dentry *dd;
356  pgoff_t index;
357  u64 ino = 0;
358  struct inode *inode;
359 
360  page = logfs_get_dd_page(dir, dentry);
361  if (IS_ERR(page))
362  return ERR_CAST(page);
363  if (!page) {
364  d_add(dentry, NULL);
365  return NULL;
366  }
367  index = page->index;
368  dd = kmap_atomic(page);
369  ino = be64_to_cpu(dd->ino);
370  kunmap_atomic(dd);
371  page_cache_release(page);
372 
373  inode = logfs_iget(dir->i_sb, ino);
374  if (IS_ERR(inode))
375  printk(KERN_ERR"LogFS: Cannot read inode #%llx for dentry (%lx, %lx)n",
376  ino, dir->i_ino, index);
377  return d_splice_alias(inode, dentry);
378 }
379 
380 static void grow_dir(struct inode *dir, loff_t index)
381 {
382  index = (index + 1) << dir->i_sb->s_blocksize_bits;
383  if (i_size_read(dir) < index)
384  i_size_write(dir, index);
385 }
386 
387 static int logfs_write_dir(struct inode *dir, struct dentry *dentry,
388  struct inode *inode)
389 {
390  struct page *page;
391  struct logfs_disk_dentry *dd;
392  u32 hash = hash_32(dentry->d_name.name, dentry->d_name.len, 0);
393  pgoff_t index;
394  int round, err;
395 
396  for (round = 0; round < 20; round++) {
397  index = hash_index(hash, round);
398 
399  if (logfs_exist_block(dir, index))
400  continue;
401  page = find_or_create_page(dir->i_mapping, index, GFP_KERNEL);
402  if (!page)
403  return -ENOMEM;
404 
405  dd = kmap_atomic(page);
406  memset(dd, 0, sizeof(*dd));
407  dd->ino = cpu_to_be64(inode->i_ino);
408  dd->type = logfs_type(inode);
409  logfs_set_name(dd, &dentry->d_name);
410  kunmap_atomic(dd);
411 
412  err = logfs_write_buf(dir, page, WF_LOCK);
413  unlock_page(page);
414  page_cache_release(page);
415  if (!err)
416  grow_dir(dir, index);
417  return err;
418  }
419  /* FIXME: Is there a better return value? In most cases neither
420  * the filesystem nor the directory are full. But we have had
421  * too many collisions for this particular hash and no fallback.
422  */
423  return -ENOSPC;
424 }
425 
426 static int __logfs_create(struct inode *dir, struct dentry *dentry,
427  struct inode *inode, const char *dest, long destlen)
428 {
429  struct logfs_super *super = logfs_super(dir->i_sb);
430  struct logfs_inode *li = logfs_inode(inode);
431  struct logfs_transaction *ta;
432  int ret;
433 
434  ta = kzalloc(sizeof(*ta), GFP_KERNEL);
435  if (!ta) {
436  drop_nlink(inode);
437  iput(inode);
438  return -ENOMEM;
439  }
440 
441  ta->state = CREATE_1;
442  ta->ino = inode->i_ino;
443  mutex_lock(&super->s_dirop_mutex);
444  logfs_add_transaction(inode, ta);
445 
446  if (dest) {
447  /* symlink */
448  ret = logfs_inode_write(inode, dest, destlen, 0, WF_LOCK, NULL);
449  if (!ret)
450  ret = write_inode(inode);
451  } else {
452  /* creat/mkdir/mknod */
453  ret = write_inode(inode);
454  }
455  if (ret) {
456  abort_transaction(inode, ta);
458  /* FIXME: truncate symlink */
459  drop_nlink(inode);
460  iput(inode);
461  goto out;
462  }
463 
464  ta->state = CREATE_2;
465  logfs_add_transaction(dir, ta);
466  ret = logfs_write_dir(dir, dentry, inode);
467  /* sync directory */
468  if (!ret)
469  ret = write_inode(dir);
470 
471  if (ret) {
472  logfs_del_transaction(dir, ta);
473  ta->state = CREATE_2;
474  logfs_add_transaction(inode, ta);
475  logfs_remove_inode(inode);
476  iput(inode);
477  goto out;
478  }
479  d_instantiate(dentry, inode);
480 out:
481  mutex_unlock(&super->s_dirop_mutex);
482  return ret;
483 }
484 
485 static int logfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
486 {
487  struct inode *inode;
488 
489  /*
490  * FIXME: why do we have to fill in S_IFDIR, while the mode is
491  * correct for mknod, creat, etc.? Smells like the vfs *should*
492  * do it for us but for some reason fails to do so.
493  */
494  inode = logfs_new_inode(dir, S_IFDIR | mode);
495  if (IS_ERR(inode))
496  return PTR_ERR(inode);
497 
498  inode->i_op = &logfs_dir_iops;
499  inode->i_fop = &logfs_dir_fops;
500 
501  return __logfs_create(dir, dentry, inode, NULL, 0);
502 }
503 
504 static int logfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
505  bool excl)
506 {
507  struct inode *inode;
508 
509  inode = logfs_new_inode(dir, mode);
510  if (IS_ERR(inode))
511  return PTR_ERR(inode);
512 
513  inode->i_op = &logfs_reg_iops;
514  inode->i_fop = &logfs_reg_fops;
515  inode->i_mapping->a_ops = &logfs_reg_aops;
516 
517  return __logfs_create(dir, dentry, inode, NULL, 0);
518 }
519 
520 static int logfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
521  dev_t rdev)
522 {
523  struct inode *inode;
524 
525  if (dentry->d_name.len > LOGFS_MAX_NAMELEN)
526  return -ENAMETOOLONG;
527 
528  inode = logfs_new_inode(dir, mode);
529  if (IS_ERR(inode))
530  return PTR_ERR(inode);
531 
532  init_special_inode(inode, mode, rdev);
533 
534  return __logfs_create(dir, dentry, inode, NULL, 0);
535 }
536 
537 static int logfs_symlink(struct inode *dir, struct dentry *dentry,
538  const char *target)
539 {
540  struct inode *inode;
541  size_t destlen = strlen(target) + 1;
542 
543  if (destlen > dir->i_sb->s_blocksize)
544  return -ENAMETOOLONG;
545 
546  inode = logfs_new_inode(dir, S_IFLNK | 0777);
547  if (IS_ERR(inode))
548  return PTR_ERR(inode);
549 
550  inode->i_op = &logfs_symlink_iops;
551  inode->i_mapping->a_ops = &logfs_reg_aops;
552 
553  return __logfs_create(dir, dentry, inode, target, destlen);
554 }
555 
556 static int logfs_link(struct dentry *old_dentry, struct inode *dir,
557  struct dentry *dentry)
558 {
559  struct inode *inode = old_dentry->d_inode;
560 
561  inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
562  ihold(inode);
563  inc_nlink(inode);
564  mark_inode_dirty_sync(inode);
565 
566  return __logfs_create(dir, dentry, inode, NULL, 0);
567 }
568 
569 static int logfs_get_dd(struct inode *dir, struct dentry *dentry,
570  struct logfs_disk_dentry *dd, loff_t *pos)
571 {
572  struct page *page;
573  void *map;
574 
575  page = logfs_get_dd_page(dir, dentry);
576  if (IS_ERR(page))
577  return PTR_ERR(page);
578  *pos = page->index;
579  map = kmap_atomic(page);
580  memcpy(dd, map, sizeof(*dd));
581  kunmap_atomic(map);
582  page_cache_release(page);
583  return 0;
584 }
585 
586 static int logfs_delete_dd(struct inode *dir, loff_t pos)
587 {
588  /*
589  * Getting called with pos somewhere beyond eof is either a goofup
590  * within this file or means someone maliciously edited the
591  * (crc-protected) journal.
592  */
593  BUG_ON(beyond_eof(dir, pos));
594  dir->i_ctime = dir->i_mtime = CURRENT_TIME;
595  log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos);
596  return logfs_delete(dir, pos, NULL);
597 }
598 
599 /*
600  * Cross-directory rename, target does not exist. Just a little nasty.
601  * Create a new dentry in the target dir, then remove the old dentry,
602  * all the while taking care to remember our operation in the journal.
603  */
604 static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry,
605  struct inode *new_dir, struct dentry *new_dentry)
606 {
607  struct logfs_super *super = logfs_super(old_dir->i_sb);
608  struct logfs_disk_dentry dd;
609  struct logfs_transaction *ta;
610  loff_t pos;
611  int err;
612 
613  /* 1. locate source dd */
614  err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
615  if (err)
616  return err;
617 
618  ta = kzalloc(sizeof(*ta), GFP_KERNEL);
619  if (!ta)
620  return -ENOMEM;
621 
622  ta->state = CROSS_RENAME_1;
623  ta->dir = old_dir->i_ino;
624  ta->pos = pos;
625 
626  /* 2. write target dd */
627  mutex_lock(&super->s_dirop_mutex);
628  logfs_add_transaction(new_dir, ta);
629  err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode);
630  if (!err)
631  err = write_inode(new_dir);
632 
633  if (err) {
634  super->s_rename_dir = 0;
635  super->s_rename_pos = 0;
636  abort_transaction(new_dir, ta);
637  goto out;
638  }
639 
640  /* 3. remove source dd */
641  ta->state = CROSS_RENAME_2;
642  logfs_add_transaction(old_dir, ta);
643  err = logfs_delete_dd(old_dir, pos);
644  if (!err)
645  err = write_inode(old_dir);
646  LOGFS_BUG_ON(err, old_dir->i_sb);
647 out:
648  mutex_unlock(&super->s_dirop_mutex);
649  return err;
650 }
651 
652 static int logfs_replace_inode(struct inode *dir, struct dentry *dentry,
653  struct logfs_disk_dentry *dd, struct inode *inode)
654 {
655  loff_t pos;
656  int err;
657 
658  err = logfs_get_dd(dir, dentry, dd, &pos);
659  if (err)
660  return err;
661  dd->ino = cpu_to_be64(inode->i_ino);
662  dd->type = logfs_type(inode);
663 
664  err = write_dir(dir, dd, pos);
665  if (err)
666  return err;
667  log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir->i_ino, pos,
668  dd->name, be64_to_cpu(dd->ino));
669  return write_inode(dir);
670 }
671 
672 /* Target dentry exists - the worst case. We need to attach the source
673  * inode to the target dentry, then remove the orphaned target inode and
674  * source dentry.
675  */
676 static int logfs_rename_target(struct inode *old_dir, struct dentry *old_dentry,
677  struct inode *new_dir, struct dentry *new_dentry)
678 {
679  struct logfs_super *super = logfs_super(old_dir->i_sb);
680  struct inode *old_inode = old_dentry->d_inode;
681  struct inode *new_inode = new_dentry->d_inode;
682  int isdir = S_ISDIR(old_inode->i_mode);
683  struct logfs_disk_dentry dd;
684  struct logfs_transaction *ta;
685  loff_t pos;
686  int err;
687 
688  BUG_ON(isdir != S_ISDIR(new_inode->i_mode));
689  if (isdir) {
690  if (!logfs_empty_dir(new_inode))
691  return -ENOTEMPTY;
692  }
693 
694  /* 1. locate source dd */
695  err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
696  if (err)
697  return err;
698 
699  ta = kzalloc(sizeof(*ta), GFP_KERNEL);
700  if (!ta)
701  return -ENOMEM;
702 
703  ta->state = TARGET_RENAME_1;
704  ta->dir = old_dir->i_ino;
705  ta->pos = pos;
706  ta->ino = new_inode->i_ino;
707 
708  /* 2. attach source inode to target dd */
709  mutex_lock(&super->s_dirop_mutex);
710  logfs_add_transaction(new_dir, ta);
711  err = logfs_replace_inode(new_dir, new_dentry, &dd, old_inode);
712  if (err) {
713  super->s_rename_dir = 0;
714  super->s_rename_pos = 0;
715  super->s_victim_ino = 0;
716  abort_transaction(new_dir, ta);
717  goto out;
718  }
719 
720  /* 3. remove source dd */
721  ta->state = TARGET_RENAME_2;
722  logfs_add_transaction(old_dir, ta);
723  err = logfs_delete_dd(old_dir, pos);
724  if (!err)
725  err = write_inode(old_dir);
726  LOGFS_BUG_ON(err, old_dir->i_sb);
727 
728  /* 4. remove target inode */
729  ta->state = TARGET_RENAME_3;
730  logfs_add_transaction(new_inode, ta);
731  err = logfs_remove_inode(new_inode);
732 
733 out:
734  mutex_unlock(&super->s_dirop_mutex);
735  return err;
736 }
737 
738 static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry,
739  struct inode *new_dir, struct dentry *new_dentry)
740 {
741  if (new_dentry->d_inode)
742  return logfs_rename_target(old_dir, old_dentry,
743  new_dir, new_dentry);
744  return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);
745 }
746 
747 /* No locking done here, as this is called before .get_sb() returns. */
749 {
750  struct logfs_super *super = logfs_super(sb);
751  struct inode *inode;
752  u64 ino, pos;
753  int err;
754 
755  if (super->s_victim_ino) {
756  /* delete victim inode */
757  ino = super->s_victim_ino;
758  printk(KERN_INFO"LogFS: delete unmapped inode #%llx\n", ino);
759  inode = logfs_iget(sb, ino);
760  if (IS_ERR(inode))
761  goto fail;
762 
763  LOGFS_BUG_ON(i_size_read(inode) > 0, sb);
764  super->s_victim_ino = 0;
765  err = logfs_remove_inode(inode);
766  iput(inode);
767  if (err) {
768  super->s_victim_ino = ino;
769  goto fail;
770  }
771  }
772  if (super->s_rename_dir) {
773  /* delete old dd from rename */
774  ino = super->s_rename_dir;
775  pos = super->s_rename_pos;
776  printk(KERN_INFO"LogFS: delete unbacked dentry (%llx, %llx)\n",
777  ino, pos);
778  inode = logfs_iget(sb, ino);
779  if (IS_ERR(inode))
780  goto fail;
781 
782  super->s_rename_dir = 0;
783  super->s_rename_pos = 0;
784  err = logfs_delete_dd(inode, pos);
785  iput(inode);
786  if (err) {
787  super->s_rename_dir = ino;
788  super->s_rename_pos = pos;
789  goto fail;
790  }
791  }
792  return 0;
793 fail:
794  LOGFS_BUG(sb);
795  return -EIO;
796 }
797 
799  .readlink = generic_readlink,
800  .follow_link = page_follow_link_light,
801 };
802 
804  .create = logfs_create,
805  .link = logfs_link,
806  .lookup = logfs_lookup,
807  .mkdir = logfs_mkdir,
808  .mknod = logfs_mknod,
809  .rename = logfs_rename,
810  .rmdir = logfs_rmdir,
811  .symlink = logfs_symlink,
812  .unlink = logfs_unlink,
813 };
815  .fsync = logfs_fsync,
816  .unlocked_ioctl = logfs_ioctl,
817  .readdir = logfs_readdir,
818  .read = generic_read_dir,
819  .llseek = default_llseek,
820 };