1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * QNX4 file system, Linux implementation. |
4 | * |
5 | * Version : 0.2.1 |
6 | * |
7 | * Using parts of the xiafs filesystem. |
8 | * |
9 | * History : |
10 | * |
11 | * 01-06-1998 by Richard Frowijn : first release. |
12 | * 20-06-1998 by Frank Denis : Linux 2.1.99+ support, boot signature, misc. |
13 | * 30-06-1998 by Frank Denis : first step to write inodes. |
14 | */ |
15 | |
16 | #include <linux/module.h> |
17 | #include <linux/init.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/highuid.h> |
20 | #include <linux/pagemap.h> |
21 | #include <linux/buffer_head.h> |
22 | #include <linux/writeback.h> |
23 | #include <linux/statfs.h> |
24 | #include "qnx4.h" |
25 | |
26 | #define QNX4_VERSION 4 |
27 | #define QNX4_BMNAME ".bitmap" |
28 | |
29 | static const struct super_operations qnx4_sops; |
30 | |
31 | static struct inode *qnx4_alloc_inode(struct super_block *sb); |
32 | static void qnx4_free_inode(struct inode *inode); |
33 | static int qnx4_remount(struct super_block *sb, int *flags, char *data); |
34 | static int qnx4_statfs(struct dentry *, struct kstatfs *); |
35 | |
36 | static const struct super_operations qnx4_sops = |
37 | { |
38 | .alloc_inode = qnx4_alloc_inode, |
39 | .free_inode = qnx4_free_inode, |
40 | .statfs = qnx4_statfs, |
41 | .remount_fs = qnx4_remount, |
42 | }; |
43 | |
44 | static int qnx4_remount(struct super_block *sb, int *flags, char *data) |
45 | { |
46 | struct qnx4_sb_info *qs; |
47 | |
48 | sync_filesystem(sb); |
49 | qs = qnx4_sb(sb); |
50 | qs->Version = QNX4_VERSION; |
51 | *flags |= SB_RDONLY; |
52 | return 0; |
53 | } |
54 | |
55 | static int qnx4_get_block( struct inode *inode, sector_t iblock, struct buffer_head *bh, int create ) |
56 | { |
57 | unsigned long phys; |
58 | |
59 | QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n" ,inode->i_ino,iblock)); |
60 | |
61 | phys = qnx4_block_map( inode, iblock ); |
62 | if ( phys ) { |
63 | // logical block is before EOF |
64 | map_bh(bh, sb: inode->i_sb, block: phys); |
65 | } |
66 | return 0; |
67 | } |
68 | |
69 | static inline u32 try_extent(qnx4_xtnt_t *extent, u32 *offset) |
70 | { |
71 | u32 size = le32_to_cpu(extent->xtnt_size); |
72 | if (*offset < size) |
73 | return le32_to_cpu(extent->xtnt_blk) + *offset - 1; |
74 | *offset -= size; |
75 | return 0; |
76 | } |
77 | |
78 | unsigned long qnx4_block_map( struct inode *inode, long iblock ) |
79 | { |
80 | int ix; |
81 | long i_xblk; |
82 | struct buffer_head *bh = NULL; |
83 | struct qnx4_xblk *xblk = NULL; |
84 | struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode); |
85 | u16 nxtnt = le16_to_cpu(qnx4_inode->di_num_xtnts); |
86 | u32 offset = iblock; |
87 | u32 block = try_extent(extent: &qnx4_inode->di_first_xtnt, offset: &offset); |
88 | |
89 | if (block) { |
90 | // iblock is in the first extent. This is easy. |
91 | } else { |
92 | // iblock is beyond first extent. We have to follow the extent chain. |
93 | i_xblk = le32_to_cpu(qnx4_inode->di_xblk); |
94 | ix = 0; |
95 | while ( --nxtnt > 0 ) { |
96 | if ( ix == 0 ) { |
97 | // read next xtnt block. |
98 | bh = sb_bread(sb: inode->i_sb, block: i_xblk - 1); |
99 | if ( !bh ) { |
100 | QNX4DEBUG((KERN_ERR "qnx4: I/O error reading xtnt block [%ld])\n" , i_xblk - 1)); |
101 | return -EIO; |
102 | } |
103 | xblk = (struct qnx4_xblk*)bh->b_data; |
104 | if ( memcmp( p: xblk->xblk_signature, q: "IamXblk" , size: 7 ) ) { |
105 | QNX4DEBUG((KERN_ERR "qnx4: block at %ld is not a valid xtnt\n" , qnx4_inode->i_xblk)); |
106 | return -EIO; |
107 | } |
108 | } |
109 | block = try_extent(extent: &xblk->xblk_xtnts[ix], offset: &offset); |
110 | if (block) { |
111 | // got it! |
112 | break; |
113 | } |
114 | if ( ++ix >= xblk->xblk_num_xtnts ) { |
115 | i_xblk = le32_to_cpu(xblk->xblk_next_xblk); |
116 | ix = 0; |
117 | brelse( bh ); |
118 | bh = NULL; |
119 | } |
120 | } |
121 | if ( bh ) |
122 | brelse( bh ); |
123 | } |
124 | |
125 | QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %ld = %ld\n" ,iblock,inode->i_ino,block)); |
126 | return block; |
127 | } |
128 | |
129 | static int qnx4_statfs(struct dentry *dentry, struct kstatfs *buf) |
130 | { |
131 | struct super_block *sb = dentry->d_sb; |
132 | u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev); |
133 | |
134 | buf->f_type = sb->s_magic; |
135 | buf->f_bsize = sb->s_blocksize; |
136 | buf->f_blocks = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size) * 8; |
137 | buf->f_bfree = qnx4_count_free_blocks(sb); |
138 | buf->f_bavail = buf->f_bfree; |
139 | buf->f_namelen = QNX4_NAME_MAX; |
140 | buf->f_fsid = u64_to_fsid(v: id); |
141 | |
142 | return 0; |
143 | } |
144 | |
145 | /* |
146 | * Check the root directory of the filesystem to make sure |
147 | * it really _is_ a qnx4 filesystem, and to check the size |
148 | * of the directory entry. |
149 | */ |
150 | static const char *qnx4_checkroot(struct super_block *sb, |
151 | struct qnx4_super_block *s) |
152 | { |
153 | struct buffer_head *bh; |
154 | struct qnx4_inode_entry *rootdir; |
155 | int rd, rl; |
156 | int i, j; |
157 | |
158 | if (s->RootDir.di_fname[0] != '/' || s->RootDir.di_fname[1] != '\0') |
159 | return "no qnx4 filesystem (no root dir)." ; |
160 | QNX4DEBUG((KERN_NOTICE "QNX4 filesystem found on dev %s.\n" , sb->s_id)); |
161 | rd = le32_to_cpu(s->RootDir.di_first_xtnt.xtnt_blk) - 1; |
162 | rl = le32_to_cpu(s->RootDir.di_first_xtnt.xtnt_size); |
163 | for (j = 0; j < rl; j++) { |
164 | bh = sb_bread(sb, block: rd + j); /* root dir, first block */ |
165 | if (bh == NULL) |
166 | return "unable to read root entry." ; |
167 | rootdir = (struct qnx4_inode_entry *) bh->b_data; |
168 | for (i = 0; i < QNX4_INODES_PER_BLOCK; i++, rootdir++) { |
169 | QNX4DEBUG((KERN_INFO "rootdir entry found : [%s]\n" , rootdir->di_fname)); |
170 | if (strcmp(rootdir->di_fname, QNX4_BMNAME) != 0) |
171 | continue; |
172 | qnx4_sb(sb)->BitMap = kmemdup(p: rootdir, |
173 | size: sizeof(struct qnx4_inode_entry), |
174 | GFP_KERNEL); |
175 | brelse(bh); |
176 | if (!qnx4_sb(sb)->BitMap) |
177 | return "not enough memory for bitmap inode" ; |
178 | /* keep bitmap inode known */ |
179 | return NULL; |
180 | } |
181 | brelse(bh); |
182 | } |
183 | return "bitmap file not found." ; |
184 | } |
185 | |
186 | static int qnx4_fill_super(struct super_block *s, void *data, int silent) |
187 | { |
188 | struct buffer_head *bh; |
189 | struct inode *root; |
190 | const char *errmsg; |
191 | struct qnx4_sb_info *qs; |
192 | |
193 | qs = kzalloc(size: sizeof(struct qnx4_sb_info), GFP_KERNEL); |
194 | if (!qs) |
195 | return -ENOMEM; |
196 | s->s_fs_info = qs; |
197 | |
198 | sb_set_blocksize(s, QNX4_BLOCK_SIZE); |
199 | |
200 | s->s_op = &qnx4_sops; |
201 | s->s_magic = QNX4_SUPER_MAGIC; |
202 | s->s_flags |= SB_RDONLY; /* Yup, read-only yet */ |
203 | s->s_time_min = 0; |
204 | s->s_time_max = U32_MAX; |
205 | |
206 | /* Check the superblock signature. Since the qnx4 code is |
207 | dangerous, we should leave as quickly as possible |
208 | if we don't belong here... */ |
209 | bh = sb_bread(sb: s, block: 1); |
210 | if (!bh) { |
211 | printk(KERN_ERR "qnx4: unable to read the superblock\n" ); |
212 | return -EINVAL; |
213 | } |
214 | |
215 | /* check before allocating dentries, inodes, .. */ |
216 | errmsg = qnx4_checkroot(sb: s, s: (struct qnx4_super_block *) bh->b_data); |
217 | brelse(bh); |
218 | if (errmsg != NULL) { |
219 | if (!silent) |
220 | printk(KERN_ERR "qnx4: %s\n" , errmsg); |
221 | return -EINVAL; |
222 | } |
223 | |
224 | /* does root not have inode number QNX4_ROOT_INO ?? */ |
225 | root = qnx4_iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK); |
226 | if (IS_ERR(ptr: root)) { |
227 | printk(KERN_ERR "qnx4: get inode failed\n" ); |
228 | return PTR_ERR(ptr: root); |
229 | } |
230 | |
231 | s->s_root = d_make_root(root); |
232 | if (s->s_root == NULL) |
233 | return -ENOMEM; |
234 | |
235 | return 0; |
236 | } |
237 | |
238 | static void qnx4_kill_sb(struct super_block *sb) |
239 | { |
240 | struct qnx4_sb_info *qs = qnx4_sb(sb); |
241 | kill_block_super(sb); |
242 | if (qs) { |
243 | kfree(objp: qs->BitMap); |
244 | kfree(objp: qs); |
245 | } |
246 | } |
247 | |
248 | static int qnx4_read_folio(struct file *file, struct folio *folio) |
249 | { |
250 | return block_read_full_folio(folio, qnx4_get_block); |
251 | } |
252 | |
253 | static sector_t qnx4_bmap(struct address_space *mapping, sector_t block) |
254 | { |
255 | return generic_block_bmap(mapping,block,qnx4_get_block); |
256 | } |
257 | |
258 | static const struct address_space_operations qnx4_aops = { |
259 | .read_folio = qnx4_read_folio, |
260 | .bmap = qnx4_bmap |
261 | }; |
262 | |
263 | struct inode *qnx4_iget(struct super_block *sb, unsigned long ino) |
264 | { |
265 | struct buffer_head *bh; |
266 | struct qnx4_inode_entry *raw_inode; |
267 | int block; |
268 | struct qnx4_inode_entry *qnx4_inode; |
269 | struct inode *inode; |
270 | |
271 | inode = iget_locked(sb, ino); |
272 | if (!inode) |
273 | return ERR_PTR(error: -ENOMEM); |
274 | if (!(inode->i_state & I_NEW)) |
275 | return inode; |
276 | |
277 | qnx4_inode = qnx4_raw_inode(inode); |
278 | inode->i_mode = 0; |
279 | |
280 | QNX4DEBUG((KERN_INFO "reading inode : [%d]\n" , ino)); |
281 | if (!ino) { |
282 | printk(KERN_ERR "qnx4: bad inode number on dev %s: %lu is " |
283 | "out of range\n" , |
284 | sb->s_id, ino); |
285 | iget_failed(inode); |
286 | return ERR_PTR(error: -EIO); |
287 | } |
288 | block = ino / QNX4_INODES_PER_BLOCK; |
289 | |
290 | if (!(bh = sb_bread(sb, block))) { |
291 | printk(KERN_ERR "qnx4: major problem: unable to read inode from dev " |
292 | "%s\n" , sb->s_id); |
293 | iget_failed(inode); |
294 | return ERR_PTR(error: -EIO); |
295 | } |
296 | raw_inode = ((struct qnx4_inode_entry *) bh->b_data) + |
297 | (ino % QNX4_INODES_PER_BLOCK); |
298 | |
299 | inode->i_mode = le16_to_cpu(raw_inode->di_mode); |
300 | i_uid_write(inode, uid: (uid_t)le16_to_cpu(raw_inode->di_uid)); |
301 | i_gid_write(inode, gid: (gid_t)le16_to_cpu(raw_inode->di_gid)); |
302 | set_nlink(inode, le16_to_cpu(raw_inode->di_nlink)); |
303 | inode->i_size = le32_to_cpu(raw_inode->di_size); |
304 | inode_set_mtime(inode, le32_to_cpu(raw_inode->di_mtime), nsec: 0); |
305 | inode_set_atime(inode, le32_to_cpu(raw_inode->di_atime), nsec: 0); |
306 | inode_set_ctime(inode, le32_to_cpu(raw_inode->di_ctime), nsec: 0); |
307 | inode->i_blocks = le32_to_cpu(raw_inode->di_first_xtnt.xtnt_size); |
308 | |
309 | memcpy(qnx4_inode, raw_inode, QNX4_DIR_ENTRY_SIZE); |
310 | if (S_ISREG(inode->i_mode)) { |
311 | inode->i_fop = &generic_ro_fops; |
312 | inode->i_mapping->a_ops = &qnx4_aops; |
313 | qnx4_i(inode)->mmu_private = inode->i_size; |
314 | } else if (S_ISDIR(inode->i_mode)) { |
315 | inode->i_op = &qnx4_dir_inode_operations; |
316 | inode->i_fop = &qnx4_dir_operations; |
317 | } else if (S_ISLNK(inode->i_mode)) { |
318 | inode->i_op = &page_symlink_inode_operations; |
319 | inode_nohighmem(inode); |
320 | inode->i_mapping->a_ops = &qnx4_aops; |
321 | qnx4_i(inode)->mmu_private = inode->i_size; |
322 | } else { |
323 | printk(KERN_ERR "qnx4: bad inode %lu on dev %s\n" , |
324 | ino, sb->s_id); |
325 | iget_failed(inode); |
326 | brelse(bh); |
327 | return ERR_PTR(error: -EIO); |
328 | } |
329 | brelse(bh); |
330 | unlock_new_inode(inode); |
331 | return inode; |
332 | } |
333 | |
334 | static struct kmem_cache *qnx4_inode_cachep; |
335 | |
336 | static struct inode *qnx4_alloc_inode(struct super_block *sb) |
337 | { |
338 | struct qnx4_inode_info *ei; |
339 | ei = alloc_inode_sb(sb, cache: qnx4_inode_cachep, GFP_KERNEL); |
340 | if (!ei) |
341 | return NULL; |
342 | return &ei->vfs_inode; |
343 | } |
344 | |
345 | static void qnx4_free_inode(struct inode *inode) |
346 | { |
347 | kmem_cache_free(s: qnx4_inode_cachep, objp: qnx4_i(inode)); |
348 | } |
349 | |
350 | static void init_once(void *foo) |
351 | { |
352 | struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo; |
353 | |
354 | inode_init_once(&ei->vfs_inode); |
355 | } |
356 | |
357 | static int init_inodecache(void) |
358 | { |
359 | qnx4_inode_cachep = kmem_cache_create(name: "qnx4_inode_cache" , |
360 | size: sizeof(struct qnx4_inode_info), |
361 | align: 0, flags: (SLAB_RECLAIM_ACCOUNT| |
362 | SLAB_MEM_SPREAD|SLAB_ACCOUNT), |
363 | ctor: init_once); |
364 | if (qnx4_inode_cachep == NULL) |
365 | return -ENOMEM; |
366 | return 0; |
367 | } |
368 | |
369 | static void destroy_inodecache(void) |
370 | { |
371 | /* |
372 | * Make sure all delayed rcu free inodes are flushed before we |
373 | * destroy cache. |
374 | */ |
375 | rcu_barrier(); |
376 | kmem_cache_destroy(s: qnx4_inode_cachep); |
377 | } |
378 | |
379 | static struct dentry *qnx4_mount(struct file_system_type *fs_type, |
380 | int flags, const char *dev_name, void *data) |
381 | { |
382 | return mount_bdev(fs_type, flags, dev_name, data, fill_super: qnx4_fill_super); |
383 | } |
384 | |
385 | static struct file_system_type qnx4_fs_type = { |
386 | .owner = THIS_MODULE, |
387 | .name = "qnx4" , |
388 | .mount = qnx4_mount, |
389 | .kill_sb = qnx4_kill_sb, |
390 | .fs_flags = FS_REQUIRES_DEV, |
391 | }; |
392 | MODULE_ALIAS_FS("qnx4" ); |
393 | |
394 | static int __init init_qnx4_fs(void) |
395 | { |
396 | int err; |
397 | |
398 | err = init_inodecache(); |
399 | if (err) |
400 | return err; |
401 | |
402 | err = register_filesystem(&qnx4_fs_type); |
403 | if (err) { |
404 | destroy_inodecache(); |
405 | return err; |
406 | } |
407 | |
408 | printk(KERN_INFO "QNX4 filesystem 0.2.3 registered.\n" ); |
409 | return 0; |
410 | } |
411 | |
412 | static void __exit exit_qnx4_fs(void) |
413 | { |
414 | unregister_filesystem(&qnx4_fs_type); |
415 | destroy_inodecache(); |
416 | } |
417 | |
418 | module_init(init_qnx4_fs) |
419 | module_exit(exit_qnx4_fs) |
420 | MODULE_LICENSE("GPL" ); |
421 | |
422 | |