1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * NILFS local header file.
4 *
5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
6 *
7 * Written by Koji Sato and Ryusuke Konishi.
8 */
9
10 #ifndef _NILFS_H
11 #define _NILFS_H
12
13 #include <linux/kernel.h>
14 #include <linux/buffer_head.h>
15 #include <linux/spinlock.h>
16 #include <linux/blkdev.h>
17 #include <linux/nilfs2_api.h>
18 #include <linux/nilfs2_ondisk.h>
19 #include "the_nilfs.h"
20 #include "bmap.h"
21
22 /**
23 * struct nilfs_inode_info - nilfs inode data in memory
24 * @i_flags: inode flags
25 * @i_state: dynamic state flags
26 * @i_bmap: pointer on i_bmap_data
27 * @i_bmap_data: raw block mapping
28 * @i_xattr: <TODO>
29 * @i_dir_start_lookup: page index of last successful search
30 * @i_cno: checkpoint number for GC inode
31 * @i_assoc_inode: associated inode (B-tree node cache holder or back pointer)
32 * @i_dirty: list for connecting dirty files
33 * @xattr_sem: semaphore for extended attributes processing
34 * @i_bh: buffer contains disk inode
35 * @i_root: root object of the current filesystem tree
36 * @vfs_inode: VFS inode object
37 */
38 struct nilfs_inode_info {
39 __u32 i_flags;
40 unsigned long i_state; /* Dynamic state flags */
41 struct nilfs_bmap *i_bmap;
42 struct nilfs_bmap i_bmap_data;
43 __u64 i_xattr; /* sector_t ??? */
44 __u32 i_dir_start_lookup;
45 __u64 i_cno; /* check point number for GC inode */
46 struct inode *i_assoc_inode;
47 struct list_head i_dirty; /* List for connecting dirty files */
48
49 #ifdef CONFIG_NILFS_XATTR
50 /*
51 * Extended attributes can be read independently of the main file
52 * data. Taking i_sem even when reading would cause contention
53 * between readers of EAs and writers of regular file data, so
54 * instead we synchronize on xattr_sem when reading or changing
55 * EAs.
56 */
57 struct rw_semaphore xattr_sem;
58 #endif
59 struct buffer_head *i_bh; /*
60 * i_bh contains a new or dirty
61 * disk inode.
62 */
63 struct nilfs_root *i_root;
64 struct inode vfs_inode;
65 };
66
67 static inline struct nilfs_inode_info *NILFS_I(const struct inode *inode)
68 {
69 return container_of(inode, struct nilfs_inode_info, vfs_inode);
70 }
71
72 static inline struct nilfs_inode_info *
73 NILFS_BMAP_I(const struct nilfs_bmap *bmap)
74 {
75 return container_of(bmap, struct nilfs_inode_info, i_bmap_data);
76 }
77
78 /*
79 * Dynamic state flags of NILFS on-memory inode (i_state)
80 */
81 enum {
82 NILFS_I_NEW = 0, /* Inode is newly created */
83 NILFS_I_DIRTY, /* The file is dirty */
84 NILFS_I_QUEUED, /* inode is in dirty_files list */
85 NILFS_I_BUSY, /*
86 * Inode is grabbed by a segment
87 * constructor
88 */
89 NILFS_I_COLLECTED, /* All dirty blocks are collected */
90 NILFS_I_UPDATED, /* The file has been written back */
91 NILFS_I_INODE_SYNC, /* dsync is not allowed for inode */
92 NILFS_I_BMAP, /* has bmap and btnode_cache */
93 NILFS_I_GCINODE, /* inode for GC, on memory only */
94 NILFS_I_BTNC, /* inode for btree node cache */
95 NILFS_I_SHADOW, /* inode for shadowed page cache */
96 };
97
98 /*
99 * commit flags for nilfs_commit_super and nilfs_sync_super
100 */
101 enum {
102 NILFS_SB_COMMIT = 0, /* Commit a super block alternately */
103 NILFS_SB_COMMIT_ALL /* Commit both super blocks */
104 };
105
106 /*
107 * Macros to check inode numbers
108 */
109 #define NILFS_MDT_INO_BITS \
110 (BIT(NILFS_DAT_INO) | BIT(NILFS_CPFILE_INO) | \
111 BIT(NILFS_SUFILE_INO) | BIT(NILFS_IFILE_INO) | \
112 BIT(NILFS_ATIME_INO) | BIT(NILFS_SKETCH_INO))
113
114 #define NILFS_SYS_INO_BITS (BIT(NILFS_ROOT_INO) | NILFS_MDT_INO_BITS)
115
116 #define NILFS_FIRST_INO(sb) (((struct the_nilfs *)sb->s_fs_info)->ns_first_ino)
117
118 #define NILFS_MDT_INODE(sb, ino) \
119 ((ino) < NILFS_USER_INO && (NILFS_MDT_INO_BITS & BIT(ino)))
120 #define NILFS_VALID_INODE(sb, ino) \
121 ((ino) >= NILFS_FIRST_INO(sb) || \
122 ((ino) < NILFS_USER_INO && (NILFS_SYS_INO_BITS & BIT(ino))))
123
124 #define NILFS_PRIVATE_INODE(ino) ({ \
125 ino_t __ino = (ino); \
126 ((__ino) < NILFS_USER_INO && (__ino) != NILFS_ROOT_INO && \
127 (__ino) != NILFS_SKETCH_INO); })
128
129 /**
130 * struct nilfs_transaction_info: context information for synchronization
131 * @ti_magic: Magic number
132 * @ti_save: Backup of journal_info field of task_struct
133 * @ti_flags: Flags
134 * @ti_count: Nest level
135 */
136 struct nilfs_transaction_info {
137 u32 ti_magic;
138 void *ti_save;
139 /*
140 * This should never be used. If it happens,
141 * one of other filesystems has a bug.
142 */
143 unsigned short ti_flags;
144 unsigned short ti_count;
145 };
146
147 /* ti_magic */
148 #define NILFS_TI_MAGIC 0xd9e392fb
149
150 /* ti_flags */
151 #define NILFS_TI_DYNAMIC_ALLOC 0x0001 /* Allocated from slab */
152 #define NILFS_TI_SYNC 0x0002 /*
153 * Force to construct segment at the
154 * end of transaction.
155 */
156 #define NILFS_TI_GC 0x0004 /* GC context */
157 #define NILFS_TI_COMMIT 0x0008 /* Change happened or not */
158 #define NILFS_TI_WRITER 0x0010 /* Constructor context */
159
160
161 int nilfs_transaction_begin(struct super_block *,
162 struct nilfs_transaction_info *, int);
163 int nilfs_transaction_commit(struct super_block *);
164 void nilfs_transaction_abort(struct super_block *);
165
166 static inline void nilfs_set_transaction_flag(unsigned int flag)
167 {
168 struct nilfs_transaction_info *ti = current->journal_info;
169
170 ti->ti_flags |= flag;
171 }
172
173 static inline int nilfs_test_transaction_flag(unsigned int flag)
174 {
175 struct nilfs_transaction_info *ti = current->journal_info;
176
177 if (ti == NULL || ti->ti_magic != NILFS_TI_MAGIC)
178 return 0;
179 return !!(ti->ti_flags & flag);
180 }
181
182 static inline int nilfs_doing_gc(void)
183 {
184 return nilfs_test_transaction_flag(NILFS_TI_GC);
185 }
186
187 static inline int nilfs_doing_construction(void)
188 {
189 return nilfs_test_transaction_flag(NILFS_TI_WRITER);
190 }
191
192 /*
193 * function prototype
194 */
195 #ifdef CONFIG_NILFS_POSIX_ACL
196 #error "NILFS: not yet supported POSIX ACL"
197 extern int nilfs_acl_chmod(struct inode *);
198 extern int nilfs_init_acl(struct inode *, struct inode *);
199 #else
200 static inline int nilfs_acl_chmod(struct inode *inode)
201 {
202 return 0;
203 }
204
205 static inline int nilfs_init_acl(struct inode *inode, struct inode *dir)
206 {
207 if (S_ISLNK(inode->i_mode))
208 return 0;
209
210 inode->i_mode &= ~current_umask();
211 return 0;
212 }
213 #endif
214
215 #define NILFS_ATIME_DISABLE
216
217 /* Flags that should be inherited by new inodes from their parent. */
218 #define NILFS_FL_INHERITED \
219 (FS_SECRM_FL | FS_UNRM_FL | FS_COMPR_FL | FS_SYNC_FL | \
220 FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NODUMP_FL | FS_NOATIME_FL |\
221 FS_COMPRBLK_FL | FS_NOCOMP_FL | FS_NOTAIL_FL | FS_DIRSYNC_FL)
222
223 /* Mask out flags that are inappropriate for the given type of inode. */
224 static inline __u32 nilfs_mask_flags(umode_t mode, __u32 flags)
225 {
226 if (S_ISDIR(mode))
227 return flags;
228 else if (S_ISREG(mode))
229 return flags & ~(FS_DIRSYNC_FL | FS_TOPDIR_FL);
230 else
231 return flags & (FS_NODUMP_FL | FS_NOATIME_FL);
232 }
233
234 /* dir.c */
235 int nilfs_add_link(struct dentry *, struct inode *);
236 int nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr, ino_t *ino);
237 int nilfs_make_empty(struct inode *, struct inode *);
238 struct nilfs_dir_entry *nilfs_find_entry(struct inode *, const struct qstr *,
239 struct folio **);
240 int nilfs_delete_entry(struct nilfs_dir_entry *, struct folio *);
241 int nilfs_empty_dir(struct inode *);
242 struct nilfs_dir_entry *nilfs_dotdot(struct inode *, struct folio **);
243 void nilfs_set_link(struct inode *, struct nilfs_dir_entry *,
244 struct folio *, struct inode *);
245
246 /* file.c */
247 extern int nilfs_sync_file(struct file *, loff_t, loff_t, int);
248
249 /* ioctl.c */
250 int nilfs_fileattr_get(struct dentry *dentry, struct fileattr *m);
251 int nilfs_fileattr_set(struct mnt_idmap *idmap,
252 struct dentry *dentry, struct fileattr *fa);
253 long nilfs_ioctl(struct file *, unsigned int, unsigned long);
254 long nilfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
255 int nilfs_ioctl_prepare_clean_segments(struct the_nilfs *, struct nilfs_argv *,
256 void **);
257
258 /* inode.c */
259 void nilfs_inode_add_blocks(struct inode *inode, int n);
260 void nilfs_inode_sub_blocks(struct inode *inode, int n);
261 extern struct inode *nilfs_new_inode(struct inode *, umode_t);
262 extern int nilfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
263 extern void nilfs_set_inode_flags(struct inode *);
264 extern int nilfs_read_inode_common(struct inode *, struct nilfs_inode *);
265 void nilfs_write_inode_common(struct inode *inode,
266 struct nilfs_inode *raw_inode);
267 struct inode *nilfs_ilookup(struct super_block *sb, struct nilfs_root *root,
268 unsigned long ino);
269 struct inode *nilfs_iget_locked(struct super_block *sb, struct nilfs_root *root,
270 unsigned long ino);
271 struct inode *nilfs_iget(struct super_block *sb, struct nilfs_root *root,
272 unsigned long ino);
273 extern struct inode *nilfs_iget_for_gc(struct super_block *sb,
274 unsigned long ino, __u64 cno);
275 int nilfs_attach_btree_node_cache(struct inode *inode);
276 void nilfs_detach_btree_node_cache(struct inode *inode);
277 struct inode *nilfs_iget_for_shadow(struct inode *inode);
278 extern void nilfs_update_inode(struct inode *, struct buffer_head *, int);
279 extern void nilfs_truncate(struct inode *);
280 extern void nilfs_evict_inode(struct inode *);
281 extern int nilfs_setattr(struct mnt_idmap *, struct dentry *,
282 struct iattr *);
283 extern void nilfs_write_failed(struct address_space *mapping, loff_t to);
284 int nilfs_permission(struct mnt_idmap *idmap, struct inode *inode,
285 int mask);
286 int nilfs_load_inode_block(struct inode *inode, struct buffer_head **pbh);
287 extern int nilfs_inode_dirty(struct inode *);
288 int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty);
289 extern int __nilfs_mark_inode_dirty(struct inode *, int);
290 extern void nilfs_dirty_inode(struct inode *, int flags);
291 int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
292 __u64 start, __u64 len);
293 static inline int nilfs_mark_inode_dirty(struct inode *inode)
294 {
295 return __nilfs_mark_inode_dirty(inode, I_DIRTY);
296 }
297 static inline int nilfs_mark_inode_dirty_sync(struct inode *inode)
298 {
299 return __nilfs_mark_inode_dirty(inode, I_DIRTY_SYNC);
300 }
301
302 /* super.c */
303 extern struct inode *nilfs_alloc_inode(struct super_block *);
304
305 __printf(2, 3)
306 void __nilfs_msg(struct super_block *sb, const char *fmt, ...);
307 extern __printf(3, 4)
308 void __nilfs_error(struct super_block *sb, const char *function,
309 const char *fmt, ...);
310
311 #ifdef CONFIG_PRINTK
312
313 #define nilfs_msg(sb, level, fmt, ...) \
314 __nilfs_msg(sb, level fmt, ##__VA_ARGS__)
315 #define nilfs_error(sb, fmt, ...) \
316 __nilfs_error(sb, __func__, fmt, ##__VA_ARGS__)
317
318 #else
319
320 #define nilfs_msg(sb, level, fmt, ...) \
321 do { \
322 no_printk(level fmt, ##__VA_ARGS__); \
323 (void)(sb); \
324 } while (0)
325 #define nilfs_error(sb, fmt, ...) \
326 do { \
327 no_printk(fmt, ##__VA_ARGS__); \
328 __nilfs_error(sb, "", " "); \
329 } while (0)
330
331 #endif /* CONFIG_PRINTK */
332
333 #define nilfs_crit(sb, fmt, ...) \
334 nilfs_msg(sb, KERN_CRIT, fmt, ##__VA_ARGS__)
335 #define nilfs_err(sb, fmt, ...) \
336 nilfs_msg(sb, KERN_ERR, fmt, ##__VA_ARGS__)
337 #define nilfs_warn(sb, fmt, ...) \
338 nilfs_msg(sb, KERN_WARNING, fmt, ##__VA_ARGS__)
339 #define nilfs_info(sb, fmt, ...) \
340 nilfs_msg(sb, KERN_INFO, fmt, ##__VA_ARGS__)
341
342 extern struct nilfs_super_block *
343 nilfs_read_super_block(struct super_block *, u64, int, struct buffer_head **);
344 extern int nilfs_store_magic(struct super_block *sb,
345 struct nilfs_super_block *sbp);
346 extern int nilfs_check_feature_compatibility(struct super_block *,
347 struct nilfs_super_block *);
348 extern void nilfs_set_log_cursor(struct nilfs_super_block *,
349 struct the_nilfs *);
350 struct nilfs_super_block **nilfs_prepare_super(struct super_block *sb,
351 int flip);
352 int nilfs_commit_super(struct super_block *sb, int flag);
353 int nilfs_cleanup_super(struct super_block *sb);
354 int nilfs_resize_fs(struct super_block *sb, __u64 newsize);
355 int nilfs_attach_checkpoint(struct super_block *sb, __u64 cno, int curr_mnt,
356 struct nilfs_root **root);
357 int nilfs_checkpoint_is_mounted(struct super_block *sb, __u64 cno);
358
359 /* gcinode.c */
360 int nilfs_gccache_submit_read_data(struct inode *, sector_t, sector_t, __u64,
361 struct buffer_head **);
362 int nilfs_gccache_submit_read_node(struct inode *, sector_t, __u64,
363 struct buffer_head **);
364 int nilfs_gccache_wait_and_mark_dirty(struct buffer_head *);
365 int nilfs_init_gcinode(struct inode *inode);
366 void nilfs_remove_all_gcinodes(struct the_nilfs *nilfs);
367
368 /* sysfs.c */
369 int __init nilfs_sysfs_init(void);
370 void nilfs_sysfs_exit(void);
371 int nilfs_sysfs_create_device_group(struct super_block *);
372 void nilfs_sysfs_delete_device_group(struct the_nilfs *);
373 int nilfs_sysfs_create_snapshot_group(struct nilfs_root *);
374 void nilfs_sysfs_delete_snapshot_group(struct nilfs_root *);
375
376 /*
377 * Inodes and files operations
378 */
379 extern const struct file_operations nilfs_dir_operations;
380 extern const struct inode_operations nilfs_file_inode_operations;
381 extern const struct file_operations nilfs_file_operations;
382 extern const struct address_space_operations nilfs_aops;
383 extern const struct inode_operations nilfs_dir_inode_operations;
384 extern const struct inode_operations nilfs_special_inode_operations;
385 extern const struct inode_operations nilfs_symlink_inode_operations;
386
387 /*
388 * filesystem type
389 */
390 extern struct file_system_type nilfs_fs_type;
391
392
393 #endif /* _NILFS_H */
394
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.