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

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

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <joern@logfs.org>
  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,
177                                 (filler_t *)logfs_readpage, NULL);
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_inode(file);
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,
303                                 (filler_t *)logfs_readpage, NULL);
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_inode(file);
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);
457                 li->li_flags |= LOGFS_IF_STILLBORN;
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. */
748 int logfs_replay_journal(struct super_block *sb)
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 
798 const struct inode_operations logfs_symlink_iops = {
799         .readlink       = generic_readlink,
800         .follow_link    = page_follow_link_light,
801 };
802 
803 const struct inode_operations logfs_dir_iops = {
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 };
814 const struct file_operations logfs_dir_fops = {
815         .fsync          = logfs_fsync,
816         .unlocked_ioctl = logfs_ioctl,
817         .readdir        = logfs_readdir,
818         .read           = generic_read_dir,
819         .llseek         = default_llseek,
820 };
821 

~ [ 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