1
2
3
4
5
6
7
8#include "logfs.h"
9#include <linux/slab.h>
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66static 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
72static int write_inode(struct inode *inode)
73{
74 return __logfs_write_inode(inode, NULL, WF_LOCK);
75}
76
77static 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
84static 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
92
93
94
95
96
97
98static 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134static 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
157static 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
196static 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
206static 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
213static 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);
259out:
260 mutex_unlock(&super->s_dirop_mutex);
261 return ret;
262}
263
264static 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
272static 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
283
284static int logfs_readdir(struct file *file, struct dir_context *ctx)
285{
286 struct inode *dir = file_inode(file);
287 loff_t pos;
288 struct page *page;
289 struct logfs_disk_dentry *dd;
290
291 if (ctx->pos < 0)
292 return -EINVAL;
293
294 if (!dir_emit_dots(file, ctx))
295 return 0;
296
297 pos = ctx->pos - 2;
298 BUG_ON(pos < 0);
299 for (;; pos++, ctx->pos++) {
300 bool full;
301 if (beyond_eof(dir, pos))
302 break;
303 if (!logfs_exist_block(dir, pos)) {
304
305 pos = dir_seek_data(dir, pos);
306 continue;
307 }
308 page = read_cache_page(dir->i_mapping, pos,
309 (filler_t *)logfs_readpage, NULL);
310 if (IS_ERR(page))
311 return PTR_ERR(page);
312 dd = kmap(page);
313 BUG_ON(dd->namelen == 0);
314
315 full = !dir_emit(ctx, (char *)dd->name,
316 be16_to_cpu(dd->namelen),
317 be64_to_cpu(dd->ino), dd->type);
318 kunmap(page);
319 page_cache_release(page);
320 if (full)
321 break;
322 }
323 return 0;
324}
325
326static void logfs_set_name(struct logfs_disk_dentry *dd, struct qstr *name)
327{
328 dd->namelen = cpu_to_be16(name->len);
329 memcpy(dd->name, name->name, name->len);
330}
331
332static struct dentry *logfs_lookup(struct inode *dir, struct dentry *dentry,
333 unsigned int flags)
334{
335 struct page *page;
336 struct logfs_disk_dentry *dd;
337 pgoff_t index;
338 u64 ino = 0;
339 struct inode *inode;
340
341 page = logfs_get_dd_page(dir, dentry);
342 if (IS_ERR(page))
343 return ERR_CAST(page);
344 if (!page) {
345 d_add(dentry, NULL);
346 return NULL;
347 }
348 index = page->index;
349 dd = kmap_atomic(page);
350 ino = be64_to_cpu(dd->ino);
351 kunmap_atomic(dd);
352 page_cache_release(page);
353
354 inode = logfs_iget(dir->i_sb, ino);
355 if (IS_ERR(inode))
356 printk(KERN_ERR"LogFS: Cannot read inode #%llx for dentry (%lx, %lx)n",
357 ino, dir->i_ino, index);
358 return d_splice_alias(inode, dentry);
359}
360
361static void grow_dir(struct inode *dir, loff_t index)
362{
363 index = (index + 1) << dir->i_sb->s_blocksize_bits;
364 if (i_size_read(dir) < index)
365 i_size_write(dir, index);
366}
367
368static int logfs_write_dir(struct inode *dir, struct dentry *dentry,
369 struct inode *inode)
370{
371 struct page *page;
372 struct logfs_disk_dentry *dd;
373 u32 hash = hash_32(dentry->d_name.name, dentry->d_name.len, 0);
374 pgoff_t index;
375 int round, err;
376
377 for (round = 0; round < 20; round++) {
378 index = hash_index(hash, round);
379
380 if (logfs_exist_block(dir, index))
381 continue;
382 page = find_or_create_page(dir->i_mapping, index, GFP_KERNEL);
383 if (!page)
384 return -ENOMEM;
385
386 dd = kmap_atomic(page);
387 memset(dd, 0, sizeof(*dd));
388 dd->ino = cpu_to_be64(inode->i_ino);
389 dd->type = logfs_type(inode);
390 logfs_set_name(dd, &dentry->d_name);
391 kunmap_atomic(dd);
392
393 err = logfs_write_buf(dir, page, WF_LOCK);
394 unlock_page(page);
395 page_cache_release(page);
396 if (!err)
397 grow_dir(dir, index);
398 return err;
399 }
400
401
402
403
404 return -ENOSPC;
405}
406
407static int __logfs_create(struct inode *dir, struct dentry *dentry,
408 struct inode *inode, const char *dest, long destlen)
409{
410 struct logfs_super *super = logfs_super(dir->i_sb);
411 struct logfs_inode *li = logfs_inode(inode);
412 struct logfs_transaction *ta;
413 int ret;
414
415 ta = kzalloc(sizeof(*ta), GFP_KERNEL);
416 if (!ta) {
417 drop_nlink(inode);
418 iput(inode);
419 return -ENOMEM;
420 }
421
422 ta->state = CREATE_1;
423 ta->ino = inode->i_ino;
424 mutex_lock(&super->s_dirop_mutex);
425 logfs_add_transaction(inode, ta);
426
427 if (dest) {
428
429 ret = logfs_inode_write(inode, dest, destlen, 0, WF_LOCK, NULL);
430 if (!ret)
431 ret = write_inode(inode);
432 } else {
433
434 ret = write_inode(inode);
435 }
436 if (ret) {
437 abort_transaction(inode, ta);
438 li->li_flags |= LOGFS_IF_STILLBORN;
439
440 drop_nlink(inode);
441 iput(inode);
442 goto out;
443 }
444
445 ta->state = CREATE_2;
446 logfs_add_transaction(dir, ta);
447 ret = logfs_write_dir(dir, dentry, inode);
448
449 if (!ret)
450 ret = write_inode(dir);
451
452 if (ret) {
453 logfs_del_transaction(dir, ta);
454 ta->state = CREATE_2;
455 logfs_add_transaction(inode, ta);
456 logfs_remove_inode(inode);
457 iput(inode);
458 goto out;
459 }
460 d_instantiate(dentry, inode);
461out:
462 mutex_unlock(&super->s_dirop_mutex);
463 return ret;
464}
465
466static int logfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
467{
468 struct inode *inode;
469
470
471
472
473
474
475 inode = logfs_new_inode(dir, S_IFDIR | mode);
476 if (IS_ERR(inode))
477 return PTR_ERR(inode);
478
479 inode->i_op = &logfs_dir_iops;
480 inode->i_fop = &logfs_dir_fops;
481
482 return __logfs_create(dir, dentry, inode, NULL, 0);
483}
484
485static int logfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
486 bool excl)
487{
488 struct inode *inode;
489
490 inode = logfs_new_inode(dir, mode);
491 if (IS_ERR(inode))
492 return PTR_ERR(inode);
493
494 inode->i_op = &logfs_reg_iops;
495 inode->i_fop = &logfs_reg_fops;
496 inode->i_mapping->a_ops = &logfs_reg_aops;
497
498 return __logfs_create(dir, dentry, inode, NULL, 0);
499}
500
501static int logfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
502 dev_t rdev)
503{
504 struct inode *inode;
505
506 if (dentry->d_name.len > LOGFS_MAX_NAMELEN)
507 return -ENAMETOOLONG;
508
509 inode = logfs_new_inode(dir, mode);
510 if (IS_ERR(inode))
511 return PTR_ERR(inode);
512
513 init_special_inode(inode, mode, rdev);
514
515 return __logfs_create(dir, dentry, inode, NULL, 0);
516}
517
518static int logfs_symlink(struct inode *dir, struct dentry *dentry,
519 const char *target)
520{
521 struct inode *inode;
522 size_t destlen = strlen(target) + 1;
523
524 if (destlen > dir->i_sb->s_blocksize)
525 return -ENAMETOOLONG;
526
527 inode = logfs_new_inode(dir, S_IFLNK | 0777);
528 if (IS_ERR(inode))
529 return PTR_ERR(inode);
530
531 inode->i_op = &logfs_symlink_iops;
532 inode->i_mapping->a_ops = &logfs_reg_aops;
533
534 return __logfs_create(dir, dentry, inode, target, destlen);
535}
536
537static int logfs_link(struct dentry *old_dentry, struct inode *dir,
538 struct dentry *dentry)
539{
540 struct inode *inode = old_dentry->d_inode;
541
542 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
543 ihold(inode);
544 inc_nlink(inode);
545 mark_inode_dirty_sync(inode);
546
547 return __logfs_create(dir, dentry, inode, NULL, 0);
548}
549
550static int logfs_get_dd(struct inode *dir, struct dentry *dentry,
551 struct logfs_disk_dentry *dd, loff_t *pos)
552{
553 struct page *page;
554 void *map;
555
556 page = logfs_get_dd_page(dir, dentry);
557 if (IS_ERR(page))
558 return PTR_ERR(page);
559 *pos = page->index;
560 map = kmap_atomic(page);
561 memcpy(dd, map, sizeof(*dd));
562 kunmap_atomic(map);
563 page_cache_release(page);
564 return 0;
565}
566
567static int logfs_delete_dd(struct inode *dir, loff_t pos)
568{
569
570
571
572
573
574 BUG_ON(beyond_eof(dir, pos));
575 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
576 log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos);
577 return logfs_delete(dir, pos, NULL);
578}
579
580
581
582
583
584
585static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry,
586 struct inode *new_dir, struct dentry *new_dentry)
587{
588 struct logfs_super *super = logfs_super(old_dir->i_sb);
589 struct logfs_disk_dentry dd;
590 struct logfs_transaction *ta;
591 loff_t pos;
592 int err;
593
594
595 err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
596 if (err)
597 return err;
598
599 ta = kzalloc(sizeof(*ta), GFP_KERNEL);
600 if (!ta)
601 return -ENOMEM;
602
603 ta->state = CROSS_RENAME_1;
604 ta->dir = old_dir->i_ino;
605 ta->pos = pos;
606
607
608 mutex_lock(&super->s_dirop_mutex);
609 logfs_add_transaction(new_dir, ta);
610 err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode);
611 if (!err)
612 err = write_inode(new_dir);
613
614 if (err) {
615 super->s_rename_dir = 0;
616 super->s_rename_pos = 0;
617 abort_transaction(new_dir, ta);
618 goto out;
619 }
620
621
622 ta->state = CROSS_RENAME_2;
623 logfs_add_transaction(old_dir, ta);
624 err = logfs_delete_dd(old_dir, pos);
625 if (!err)
626 err = write_inode(old_dir);
627 LOGFS_BUG_ON(err, old_dir->i_sb);
628out:
629 mutex_unlock(&super->s_dirop_mutex);
630 return err;
631}
632
633static int logfs_replace_inode(struct inode *dir, struct dentry *dentry,
634 struct logfs_disk_dentry *dd, struct inode *inode)
635{
636 loff_t pos;
637 int err;
638
639 err = logfs_get_dd(dir, dentry, dd, &pos);
640 if (err)
641 return err;
642 dd->ino = cpu_to_be64(inode->i_ino);
643 dd->type = logfs_type(inode);
644
645 err = write_dir(dir, dd, pos);
646 if (err)
647 return err;
648 log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir->i_ino, pos,
649 dd->name, be64_to_cpu(dd->ino));
650 return write_inode(dir);
651}
652
653
654
655
656
657static int logfs_rename_target(struct inode *old_dir, struct dentry *old_dentry,
658 struct inode *new_dir, struct dentry *new_dentry)
659{
660 struct logfs_super *super = logfs_super(old_dir->i_sb);
661 struct inode *old_inode = old_dentry->d_inode;
662 struct inode *new_inode = new_dentry->d_inode;
663 int isdir = S_ISDIR(old_inode->i_mode);
664 struct logfs_disk_dentry dd;
665 struct logfs_transaction *ta;
666 loff_t pos;
667 int err;
668
669 BUG_ON(isdir != S_ISDIR(new_inode->i_mode));
670 if (isdir) {
671 if (!logfs_empty_dir(new_inode))
672 return -ENOTEMPTY;
673 }
674
675
676 err = logfs_get_dd(old_dir, old_dentry, &dd, &pos);
677 if (err)
678 return err;
679
680 ta = kzalloc(sizeof(*ta), GFP_KERNEL);
681 if (!ta)
682 return -ENOMEM;
683
684 ta->state = TARGET_RENAME_1;
685 ta->dir = old_dir->i_ino;
686 ta->pos = pos;
687 ta->ino = new_inode->i_ino;
688
689
690 mutex_lock(&super->s_dirop_mutex);
691 logfs_add_transaction(new_dir, ta);
692 err = logfs_replace_inode(new_dir, new_dentry, &dd, old_inode);
693 if (err) {
694 super->s_rename_dir = 0;
695 super->s_rename_pos = 0;
696 super->s_victim_ino = 0;
697 abort_transaction(new_dir, ta);
698 goto out;
699 }
700
701
702 ta->state = TARGET_RENAME_2;
703 logfs_add_transaction(old_dir, ta);
704 err = logfs_delete_dd(old_dir, pos);
705 if (!err)
706 err = write_inode(old_dir);
707 LOGFS_BUG_ON(err, old_dir->i_sb);
708
709
710 ta->state = TARGET_RENAME_3;
711 logfs_add_transaction(new_inode, ta);
712 err = logfs_remove_inode(new_inode);
713
714out:
715 mutex_unlock(&super->s_dirop_mutex);
716 return err;
717}
718
719static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry,
720 struct inode *new_dir, struct dentry *new_dentry)
721{
722 if (new_dentry->d_inode)
723 return logfs_rename_target(old_dir, old_dentry,
724 new_dir, new_dentry);
725 return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);
726}
727
728
729int logfs_replay_journal(struct super_block *sb)
730{
731 struct logfs_super *super = logfs_super(sb);
732 struct inode *inode;
733 u64 ino, pos;
734 int err;
735
736 if (super->s_victim_ino) {
737
738 ino = super->s_victim_ino;
739 printk(KERN_INFO"LogFS: delete unmapped inode #%llx\n", ino);
740 inode = logfs_iget(sb, ino);
741 if (IS_ERR(inode))
742 goto fail;
743
744 LOGFS_BUG_ON(i_size_read(inode) > 0, sb);
745 super->s_victim_ino = 0;
746 err = logfs_remove_inode(inode);
747 iput(inode);
748 if (err) {
749 super->s_victim_ino = ino;
750 goto fail;
751 }
752 }
753 if (super->s_rename_dir) {
754
755 ino = super->s_rename_dir;
756 pos = super->s_rename_pos;
757 printk(KERN_INFO"LogFS: delete unbacked dentry (%llx, %llx)\n",
758 ino, pos);
759 inode = logfs_iget(sb, ino);
760 if (IS_ERR(inode))
761 goto fail;
762
763 super->s_rename_dir = 0;
764 super->s_rename_pos = 0;
765 err = logfs_delete_dd(inode, pos);
766 iput(inode);
767 if (err) {
768 super->s_rename_dir = ino;
769 super->s_rename_pos = pos;
770 goto fail;
771 }
772 }
773 return 0;
774fail:
775 LOGFS_BUG(sb);
776 return -EIO;
777}
778
779const struct inode_operations logfs_symlink_iops = {
780 .readlink = generic_readlink,
781 .follow_link = page_follow_link_light,
782};
783
784const struct inode_operations logfs_dir_iops = {
785 .create = logfs_create,
786 .link = logfs_link,
787 .lookup = logfs_lookup,
788 .mkdir = logfs_mkdir,
789 .mknod = logfs_mknod,
790 .rename = logfs_rename,
791 .rmdir = logfs_rmdir,
792 .symlink = logfs_symlink,
793 .unlink = logfs_unlink,
794};
795const struct file_operations logfs_dir_fops = {
796 .fsync = logfs_fsync,
797 .unlocked_ioctl = logfs_ioctl,
798 .iterate = logfs_readdir,
799 .read = generic_read_dir,
800 .llseek = default_llseek,
801};
802