2 * fs/logfs/dir.c - directory-related code
4 * As should be obvious for Linux kernel code, license is GPLv2
6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
9 #include <linux/slab.h>
12 * Atomic dir operations
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.
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)
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.
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)
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.
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.
42 * Local rename is atomic, as the old dentry is simply rewritten with a new
45 * Cross-directory rename works in two steps, similar to __logfs_create and
47 * 1. Write new dentry (remember old dentry in journal)
48 * 2. Remove old dentry (clear journal)
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.
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
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.
66 static int write_dir(struct inode
*dir
, struct logfs_disk_dentry
*dd
,
69 return logfs_inode_write(dir
, dd
, sizeof(*dd
), pos
, WF_LOCK
, NULL
);
72 static int write_inode(struct inode
*inode
)
74 return __logfs_write_inode(inode
, WF_LOCK
);
77 static s64
dir_seek_data(struct inode
*inode
, s64 pos
)
79 s64 new_pos
= logfs_seek_data(inode
, pos
);
81 return max(pos
, new_pos
- 1);
84 static int beyond_eof(struct inode
*inode
, loff_t bix
)
86 loff_t pos
= bix
<< inode
->i_sb
->s_blocksize_bits
;
87 return pos
>= i_size_read(inode
);
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
98 static u32
hash_32(const char *s
, int len
, u32 seed
)
103 for (i
= 0; i
< len
; i
++)
104 hash
= hash
* 293 + s
[i
];
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
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.
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
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.
134 static pgoff_t
hash_index(u32 hash
, int round
)
136 u32 i0_blocks
= I0_BLOCKS
;
137 u32 i1_blocks
= I1_BLOCKS
;
138 u32 i2_blocks
= I2_BLOCKS
;
139 u32 i3_blocks
= I3_BLOCKS
;
143 return hash
% i0_blocks
;
145 return i0_blocks
+ hash
% (i1_blocks
- i0_blocks
);
147 return i1_blocks
+ hash
% (i2_blocks
- i1_blocks
);
149 return i2_blocks
+ hash
% (i3_blocks
- i2_blocks
);
151 return i3_blocks
+ 16 * (hash
% (((1<<31) - i3_blocks
) / 16))
157 static struct page
*logfs_get_dd_page(struct inode
*dir
, struct dentry
*dentry
)
159 struct qstr
*name
= &dentry
->d_name
;
161 struct logfs_disk_dentry
*dd
;
162 u32 hash
= hash_32(name
->name
, name
->len
, 0);
166 if (name
->len
> LOGFS_MAX_NAMELEN
)
167 return ERR_PTR(-ENAMETOOLONG
);
169 for (round
= 0; round
< 20; round
++) {
170 index
= hash_index(hash
, round
);
172 if (beyond_eof(dir
, index
))
174 if (!logfs_exist_block(dir
, index
))
176 page
= read_cache_page(dir
->i_mapping
, index
,
177 (filler_t
*)logfs_readpage
, NULL
);
180 dd
= kmap_atomic(page
, KM_USER0
);
181 BUG_ON(dd
->namelen
== 0);
183 if (name
->len
!= be16_to_cpu(dd
->namelen
) ||
184 memcmp(name
->name
, dd
->name
, name
->len
)) {
185 kunmap_atomic(dd
, KM_USER0
);
186 page_cache_release(page
);
190 kunmap_atomic(dd
, KM_USER0
);
196 static int logfs_remove_inode(struct inode
*inode
)
201 ret
= write_inode(inode
);
202 LOGFS_BUG_ON(ret
, inode
->i_sb
);
206 static void abort_transaction(struct inode
*inode
, struct logfs_transaction
*ta
)
208 if (logfs_inode(inode
)->li_block
)
209 logfs_inode(inode
)->li_block
->ta
= NULL
;
213 static int logfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
215 struct logfs_super
*super
= logfs_super(dir
->i_sb
);
216 struct inode
*inode
= dentry
->d_inode
;
217 struct logfs_transaction
*ta
;
222 ta
= kzalloc(sizeof(*ta
), GFP_KERNEL
);
226 ta
->state
= UNLINK_1
;
227 ta
->ino
= inode
->i_ino
;
229 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
231 page
= logfs_get_dd_page(dir
, dentry
);
238 return PTR_ERR(page
);
241 page_cache_release(page
);
243 mutex_lock(&super
->s_dirop_mutex
);
244 logfs_add_transaction(dir
, ta
);
246 ret
= logfs_delete(dir
, index
, NULL
);
248 ret
= write_inode(dir
);
251 abort_transaction(dir
, ta
);
252 printk(KERN_ERR
"LOGFS: unable to delete inode\n");
256 ta
->state
= UNLINK_2
;
257 logfs_add_transaction(inode
, ta
);
258 ret
= logfs_remove_inode(inode
);
260 mutex_unlock(&super
->s_dirop_mutex
);
264 static inline int logfs_empty_dir(struct inode
*dir
)
268 data
= logfs_seek_data(dir
, 0) << dir
->i_sb
->s_blocksize_bits
;
269 return data
>= i_size_read(dir
);
272 static int logfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
274 struct inode
*inode
= dentry
->d_inode
;
276 if (!logfs_empty_dir(inode
))
279 return logfs_unlink(dir
, dentry
);
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
)
287 struct inode
*dir
= file
->f_dentry
->d_inode
;
288 loff_t pos
= file
->f_pos
- IMPLICIT_NODES
;
290 struct logfs_disk_dentry
*dd
;
295 if (beyond_eof(dir
, pos
))
297 if (!logfs_exist_block(dir
, pos
)) {
299 pos
= dir_seek_data(dir
, pos
);
302 page
= read_cache_page(dir
->i_mapping
, pos
,
303 (filler_t
*)logfs_readpage
, NULL
);
305 return PTR_ERR(page
);
307 BUG_ON(dd
->namelen
== 0);
309 full
= filldir(buf
, (char *)dd
->name
, be16_to_cpu(dd
->namelen
),
310 pos
, be64_to_cpu(dd
->ino
), dd
->type
);
312 page_cache_release(page
);
317 file
->f_pos
= pos
+ IMPLICIT_NODES
;
321 static int logfs_readdir(struct file
*file
, void *buf
, filldir_t filldir
)
323 struct inode
*inode
= file
->f_dentry
->d_inode
;
324 ino_t pino
= parent_ino(file
->f_dentry
);
330 if (file
->f_pos
== 0) {
331 if (filldir(buf
, ".", 1, 1, inode
->i_ino
, DT_DIR
) < 0)
335 if (file
->f_pos
== 1) {
336 if (filldir(buf
, "..", 2, 2, pino
, DT_DIR
) < 0)
341 err
= __logfs_readdir(file
, buf
, filldir
);
345 static void logfs_set_name(struct logfs_disk_dentry
*dd
, struct qstr
*name
)
347 dd
->namelen
= cpu_to_be16(name
->len
);
348 memcpy(dd
->name
, name
->name
, name
->len
);
351 static struct dentry
*logfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
352 struct nameidata
*nd
)
355 struct logfs_disk_dentry
*dd
;
360 page
= logfs_get_dd_page(dir
, dentry
);
362 return ERR_CAST(page
);
368 dd
= kmap_atomic(page
, KM_USER0
);
369 ino
= be64_to_cpu(dd
->ino
);
370 kunmap_atomic(dd
, KM_USER0
);
371 page_cache_release(page
);
373 inode
= logfs_iget(dir
->i_sb
, ino
);
375 printk(KERN_ERR
"LogFS: Cannot read inode #%llx for dentry (%lx, %lx)n",
376 ino
, dir
->i_ino
, index
);
377 return ERR_CAST(inode
);
379 return d_splice_alias(inode
, dentry
);
382 static void grow_dir(struct inode
*dir
, loff_t index
)
384 index
= (index
+ 1) << dir
->i_sb
->s_blocksize_bits
;
385 if (i_size_read(dir
) < index
)
386 i_size_write(dir
, index
);
389 static int logfs_write_dir(struct inode
*dir
, struct dentry
*dentry
,
393 struct logfs_disk_dentry
*dd
;
394 u32 hash
= hash_32(dentry
->d_name
.name
, dentry
->d_name
.len
, 0);
398 for (round
= 0; round
< 20; round
++) {
399 index
= hash_index(hash
, round
);
401 if (logfs_exist_block(dir
, index
))
403 page
= find_or_create_page(dir
->i_mapping
, index
, GFP_KERNEL
);
407 dd
= kmap_atomic(page
, KM_USER0
);
408 memset(dd
, 0, sizeof(*dd
));
409 dd
->ino
= cpu_to_be64(inode
->i_ino
);
410 dd
->type
= logfs_type(inode
);
411 logfs_set_name(dd
, &dentry
->d_name
);
412 kunmap_atomic(dd
, KM_USER0
);
414 err
= logfs_write_buf(dir
, page
, WF_LOCK
);
416 page_cache_release(page
);
418 grow_dir(dir
, index
);
421 /* FIXME: Is there a better return value? In most cases neither
422 * the filesystem nor the directory are full. But we have had
423 * too many collisions for this particular hash and no fallback.
428 static int __logfs_create(struct inode
*dir
, struct dentry
*dentry
,
429 struct inode
*inode
, const char *dest
, long destlen
)
431 struct logfs_super
*super
= logfs_super(dir
->i_sb
);
432 struct logfs_inode
*li
= logfs_inode(inode
);
433 struct logfs_transaction
*ta
;
436 ta
= kzalloc(sizeof(*ta
), GFP_KERNEL
);
443 ta
->state
= CREATE_1
;
444 ta
->ino
= inode
->i_ino
;
445 mutex_lock(&super
->s_dirop_mutex
);
446 logfs_add_transaction(inode
, ta
);
450 ret
= logfs_inode_write(inode
, dest
, destlen
, 0, WF_LOCK
, NULL
);
452 ret
= write_inode(inode
);
454 /* creat/mkdir/mknod */
455 ret
= write_inode(inode
);
458 abort_transaction(inode
, ta
);
459 li
->li_flags
|= LOGFS_IF_STILLBORN
;
460 /* FIXME: truncate symlink */
466 ta
->state
= CREATE_2
;
467 logfs_add_transaction(dir
, ta
);
468 ret
= logfs_write_dir(dir
, dentry
, inode
);
471 ret
= write_inode(dir
);
474 logfs_del_transaction(dir
, ta
);
475 ta
->state
= CREATE_2
;
476 logfs_add_transaction(inode
, ta
);
477 logfs_remove_inode(inode
);
481 d_instantiate(dentry
, inode
);
483 mutex_unlock(&super
->s_dirop_mutex
);
487 static int logfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
492 * FIXME: why do we have to fill in S_IFDIR, while the mode is
493 * correct for mknod, creat, etc.? Smells like the vfs *should*
494 * do it for us but for some reason fails to do so.
496 inode
= logfs_new_inode(dir
, S_IFDIR
| mode
);
498 return PTR_ERR(inode
);
500 inode
->i_op
= &logfs_dir_iops
;
501 inode
->i_fop
= &logfs_dir_fops
;
503 return __logfs_create(dir
, dentry
, inode
, NULL
, 0);
506 static int logfs_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
507 struct nameidata
*nd
)
511 inode
= logfs_new_inode(dir
, mode
);
513 return PTR_ERR(inode
);
515 inode
->i_op
= &logfs_reg_iops
;
516 inode
->i_fop
= &logfs_reg_fops
;
517 inode
->i_mapping
->a_ops
= &logfs_reg_aops
;
519 return __logfs_create(dir
, dentry
, inode
, NULL
, 0);
522 static int logfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
,
527 if (dentry
->d_name
.len
> LOGFS_MAX_NAMELEN
)
528 return -ENAMETOOLONG
;
530 inode
= logfs_new_inode(dir
, mode
);
532 return PTR_ERR(inode
);
534 init_special_inode(inode
, mode
, rdev
);
536 return __logfs_create(dir
, dentry
, inode
, NULL
, 0);
539 static int logfs_symlink(struct inode
*dir
, struct dentry
*dentry
,
543 size_t destlen
= strlen(target
) + 1;
545 if (destlen
> dir
->i_sb
->s_blocksize
)
546 return -ENAMETOOLONG
;
548 inode
= logfs_new_inode(dir
, S_IFLNK
| 0777);
550 return PTR_ERR(inode
);
552 inode
->i_op
= &logfs_symlink_iops
;
553 inode
->i_mapping
->a_ops
= &logfs_reg_aops
;
555 return __logfs_create(dir
, dentry
, inode
, target
, destlen
);
558 static int logfs_permission(struct inode
*inode
, int mask
, unsigned int flags
)
560 if (flags
& IPERM_FLAG_RCU
)
562 return generic_permission(inode
, mask
, flags
, NULL
);
565 static int logfs_link(struct dentry
*old_dentry
, struct inode
*dir
,
566 struct dentry
*dentry
)
568 struct inode
*inode
= old_dentry
->d_inode
;
570 if (inode
->i_nlink
>= LOGFS_LINK_MAX
)
573 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
576 mark_inode_dirty_sync(inode
);
578 return __logfs_create(dir
, dentry
, inode
, NULL
, 0);
581 static int logfs_get_dd(struct inode
*dir
, struct dentry
*dentry
,
582 struct logfs_disk_dentry
*dd
, loff_t
*pos
)
587 page
= logfs_get_dd_page(dir
, dentry
);
589 return PTR_ERR(page
);
591 map
= kmap_atomic(page
, KM_USER0
);
592 memcpy(dd
, map
, sizeof(*dd
));
593 kunmap_atomic(map
, KM_USER0
);
594 page_cache_release(page
);
598 static int logfs_delete_dd(struct inode
*dir
, loff_t pos
)
601 * Getting called with pos somewhere beyond eof is either a goofup
602 * within this file or means someone maliciously edited the
603 * (crc-protected) journal.
605 BUG_ON(beyond_eof(dir
, pos
));
606 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
607 log_dir(" Delete dentry (%lx, %llx)\n", dir
->i_ino
, pos
);
608 return logfs_delete(dir
, pos
, NULL
);
612 * Cross-directory rename, target does not exist. Just a little nasty.
613 * Create a new dentry in the target dir, then remove the old dentry,
614 * all the while taking care to remember our operation in the journal.
616 static int logfs_rename_cross(struct inode
*old_dir
, struct dentry
*old_dentry
,
617 struct inode
*new_dir
, struct dentry
*new_dentry
)
619 struct logfs_super
*super
= logfs_super(old_dir
->i_sb
);
620 struct logfs_disk_dentry dd
;
621 struct logfs_transaction
*ta
;
625 /* 1. locate source dd */
626 err
= logfs_get_dd(old_dir
, old_dentry
, &dd
, &pos
);
630 ta
= kzalloc(sizeof(*ta
), GFP_KERNEL
);
634 ta
->state
= CROSS_RENAME_1
;
635 ta
->dir
= old_dir
->i_ino
;
638 /* 2. write target dd */
639 mutex_lock(&super
->s_dirop_mutex
);
640 logfs_add_transaction(new_dir
, ta
);
641 err
= logfs_write_dir(new_dir
, new_dentry
, old_dentry
->d_inode
);
643 err
= write_inode(new_dir
);
646 super
->s_rename_dir
= 0;
647 super
->s_rename_pos
= 0;
648 abort_transaction(new_dir
, ta
);
652 /* 3. remove source dd */
653 ta
->state
= CROSS_RENAME_2
;
654 logfs_add_transaction(old_dir
, ta
);
655 err
= logfs_delete_dd(old_dir
, pos
);
657 err
= write_inode(old_dir
);
658 LOGFS_BUG_ON(err
, old_dir
->i_sb
);
660 mutex_unlock(&super
->s_dirop_mutex
);
664 static int logfs_replace_inode(struct inode
*dir
, struct dentry
*dentry
,
665 struct logfs_disk_dentry
*dd
, struct inode
*inode
)
670 err
= logfs_get_dd(dir
, dentry
, dd
, &pos
);
673 dd
->ino
= cpu_to_be64(inode
->i_ino
);
674 dd
->type
= logfs_type(inode
);
676 err
= write_dir(dir
, dd
, pos
);
679 log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir
->i_ino
, pos
,
680 dd
->name
, be64_to_cpu(dd
->ino
));
681 return write_inode(dir
);
684 /* Target dentry exists - the worst case. We need to attach the source
685 * inode to the target dentry, then remove the orphaned target inode and
688 static int logfs_rename_target(struct inode
*old_dir
, struct dentry
*old_dentry
,
689 struct inode
*new_dir
, struct dentry
*new_dentry
)
691 struct logfs_super
*super
= logfs_super(old_dir
->i_sb
);
692 struct inode
*old_inode
= old_dentry
->d_inode
;
693 struct inode
*new_inode
= new_dentry
->d_inode
;
694 int isdir
= S_ISDIR(old_inode
->i_mode
);
695 struct logfs_disk_dentry dd
;
696 struct logfs_transaction
*ta
;
700 BUG_ON(isdir
!= S_ISDIR(new_inode
->i_mode
));
702 if (!logfs_empty_dir(new_inode
))
706 /* 1. locate source dd */
707 err
= logfs_get_dd(old_dir
, old_dentry
, &dd
, &pos
);
711 ta
= kzalloc(sizeof(*ta
), GFP_KERNEL
);
715 ta
->state
= TARGET_RENAME_1
;
716 ta
->dir
= old_dir
->i_ino
;
718 ta
->ino
= new_inode
->i_ino
;
720 /* 2. attach source inode to target dd */
721 mutex_lock(&super
->s_dirop_mutex
);
722 logfs_add_transaction(new_dir
, ta
);
723 err
= logfs_replace_inode(new_dir
, new_dentry
, &dd
, old_inode
);
725 super
->s_rename_dir
= 0;
726 super
->s_rename_pos
= 0;
727 super
->s_victim_ino
= 0;
728 abort_transaction(new_dir
, ta
);
732 /* 3. remove source dd */
733 ta
->state
= TARGET_RENAME_2
;
734 logfs_add_transaction(old_dir
, ta
);
735 err
= logfs_delete_dd(old_dir
, pos
);
737 err
= write_inode(old_dir
);
738 LOGFS_BUG_ON(err
, old_dir
->i_sb
);
740 /* 4. remove target inode */
741 ta
->state
= TARGET_RENAME_3
;
742 logfs_add_transaction(new_inode
, ta
);
743 err
= logfs_remove_inode(new_inode
);
746 mutex_unlock(&super
->s_dirop_mutex
);
750 static int logfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
751 struct inode
*new_dir
, struct dentry
*new_dentry
)
753 if (new_dentry
->d_inode
)
754 return logfs_rename_target(old_dir
, old_dentry
,
755 new_dir
, new_dentry
);
756 return logfs_rename_cross(old_dir
, old_dentry
, new_dir
, new_dentry
);
759 /* No locking done here, as this is called before .get_sb() returns. */
760 int logfs_replay_journal(struct super_block
*sb
)
762 struct logfs_super
*super
= logfs_super(sb
);
767 if (super
->s_victim_ino
) {
768 /* delete victim inode */
769 ino
= super
->s_victim_ino
;
770 printk(KERN_INFO
"LogFS: delete unmapped inode #%llx\n", ino
);
771 inode
= logfs_iget(sb
, ino
);
775 LOGFS_BUG_ON(i_size_read(inode
) > 0, sb
);
776 super
->s_victim_ino
= 0;
777 err
= logfs_remove_inode(inode
);
780 super
->s_victim_ino
= ino
;
784 if (super
->s_rename_dir
) {
785 /* delete old dd from rename */
786 ino
= super
->s_rename_dir
;
787 pos
= super
->s_rename_pos
;
788 printk(KERN_INFO
"LogFS: delete unbacked dentry (%llx, %llx)\n",
790 inode
= logfs_iget(sb
, ino
);
794 super
->s_rename_dir
= 0;
795 super
->s_rename_pos
= 0;
796 err
= logfs_delete_dd(inode
, pos
);
799 super
->s_rename_dir
= ino
;
800 super
->s_rename_pos
= pos
;
810 const struct inode_operations logfs_symlink_iops
= {
811 .readlink
= generic_readlink
,
812 .follow_link
= page_follow_link_light
,
815 const struct inode_operations logfs_dir_iops
= {
816 .create
= logfs_create
,
818 .lookup
= logfs_lookup
,
819 .mkdir
= logfs_mkdir
,
820 .mknod
= logfs_mknod
,
821 .rename
= logfs_rename
,
822 .rmdir
= logfs_rmdir
,
823 .permission
= logfs_permission
,
824 .symlink
= logfs_symlink
,
825 .unlink
= logfs_unlink
,
827 const struct file_operations logfs_dir_fops
= {
828 .fsync
= logfs_fsync
,
829 .unlocked_ioctl
= logfs_ioctl
,
830 .readdir
= logfs_readdir
,
831 .read
= generic_read_dir
,
832 .llseek
= default_llseek
,