inode.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Optimized MPEG FS - inode and super operations.
  4 * Copyright (C) 2006 Bob Copeland <me@bobcopeland.com>
  5 */
  6#include <linux/module.h>
  7#include <linux/sched.h>
  8#include <linux/slab.h>
  9#include <linux/fs.h>
 10#include <linux/vfs.h>
 11#include <linux/cred.h>
 12#include <linux/buffer_head.h>
 13#include <linux/vmalloc.h>
 14#include <linux/writeback.h>
 15#include <linux/seq_file.h>
 16#include <linux/crc-itu-t.h>
 17#include <linux/fs_struct.h>
 18#include <linux/fs_context.h>
 19#include <linux/fs_parser.h>
 20#include "omfs.h"
 21
 22MODULE_AUTHOR("Bob Copeland <me@bobcopeland.com>");
 23MODULE_DESCRIPTION("OMFS (ReplayTV/Karma) Filesystem for Linux");
 24MODULE_LICENSE("GPL");
 25
 26struct buffer_head *omfs_bread(struct super_block *sb, sector_t block)
 27{
 28	struct omfs_sb_info *sbi = OMFS_SB(sb);
 29	if (block >= sbi->s_num_blocks)
 30		return NULL;
 31
 32	return sb_bread(sb, clus_to_blk(sbi, block));
 33}
 34
 35struct inode *omfs_new_inode(struct inode *dir, umode_t mode)
 36{
 37	struct inode *inode;
 38	u64 new_block;
 39	int err;
 40	int len;
 41	struct omfs_sb_info *sbi = OMFS_SB(dir->i_sb);
 42
 43	inode = new_inode(dir->i_sb);
 44	if (!inode)
 45		return ERR_PTR(-ENOMEM);
 46
 47	err = omfs_allocate_range(dir->i_sb, sbi->s_mirrors, sbi->s_mirrors,
 48			&new_block, &len);
 49	if (err)
 50		goto fail;
 51
 52	inode->i_ino = new_block;
 53	inode_init_owner(&nop_mnt_idmap, inode, NULL, mode);
 54	inode->i_mapping->a_ops = &omfs_aops;
 55
 56	simple_inode_init_ts(inode);
 57	switch (mode & S_IFMT) {
 58	case S_IFDIR:
 59		inode->i_op = &omfs_dir_inops;
 60		inode->i_fop = &omfs_dir_operations;
 61		inode->i_size = sbi->s_sys_blocksize;
 62		inc_nlink(inode);
 63		break;
 64	case S_IFREG:
 65		inode->i_op = &omfs_file_inops;
 66		inode->i_fop = &omfs_file_operations;
 67		inode->i_size = 0;
 68		break;
 69	}
 70
 71	insert_inode_hash(inode);
 72	mark_inode_dirty(inode);
 73	return inode;
 74fail:
 75	make_bad_inode(inode);
 76	iput(inode);
 77	return ERR_PTR(err);
 78}
 79
 80/*
 81 * Update the header checksums for a dirty inode based on its contents.
 82 * Caller is expected to hold the buffer head underlying oi and mark it
 83 * dirty.
 84 */
 85static void omfs_update_checksums(struct omfs_inode *oi)
 86{
 87	int xor, i, ofs = 0, count;
 88	u16 crc = 0;
 89	unsigned char *ptr = (unsigned char *) oi;
 90
 91	count = be32_to_cpu(oi->i_head.h_body_size);
 92	ofs = sizeof(struct omfs_header);
 93
 94	crc = crc_itu_t(crc, ptr + ofs, count);
 95	oi->i_head.h_crc = cpu_to_be16(crc);
 96
 97	xor = ptr[0];
 98	for (i = 1; i < OMFS_XOR_COUNT; i++)
 99		xor ^= ptr[i];
100
101	oi->i_head.h_check_xor = xor;
102}
103
104static int __omfs_write_inode(struct inode *inode, int wait)
105{
106	struct omfs_inode *oi;
107	struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb);
108	struct buffer_head *bh, *bh2;
109	u64 ctime;
110	int i;
111	int ret = -EIO;
112	int sync_failed = 0;
113
114	/* get current inode since we may have written sibling ptrs etc. */
115	bh = omfs_bread(inode->i_sb, inode->i_ino);
116	if (!bh)
117		goto out;
118
119	oi = (struct omfs_inode *) bh->b_data;
120
121	oi->i_head.h_self = cpu_to_be64(inode->i_ino);
122	if (S_ISDIR(inode->i_mode))
123		oi->i_type = OMFS_DIR;
124	else if (S_ISREG(inode->i_mode))
125		oi->i_type = OMFS_FILE;
126	else {
127		printk(KERN_WARNING "omfs: unknown file type: %d\n",
128			inode->i_mode);
129		goto out_brelse;
130	}
131
132	oi->i_head.h_body_size = cpu_to_be32(sbi->s_sys_blocksize -
133		sizeof(struct omfs_header));
134	oi->i_head.h_version = 1;
135	oi->i_head.h_type = OMFS_INODE_NORMAL;
136	oi->i_head.h_magic = OMFS_IMAGIC;
137	oi->i_size = cpu_to_be64(inode->i_size);
138
139	ctime = inode_get_ctime_sec(inode) * 1000LL +
140		((inode_get_ctime_nsec(inode) + 999)/1000);
141	oi->i_ctime = cpu_to_be64(ctime);
142
143	omfs_update_checksums(oi);
144
145	mark_buffer_dirty(bh);
146	if (wait) {
147		sync_dirty_buffer(bh);
148		if (buffer_req(bh) && !buffer_uptodate(bh))
149			sync_failed = 1;
150	}
151
152	/* if mirroring writes, copy to next fsblock */
153	for (i = 1; i < sbi->s_mirrors; i++) {
154		bh2 = omfs_bread(inode->i_sb, inode->i_ino + i);
155		if (!bh2)
156			goto out_brelse;
157
158		memcpy(bh2->b_data, bh->b_data, bh->b_size);
159		mark_buffer_dirty(bh2);
160		if (wait) {
161			sync_dirty_buffer(bh2);
162			if (buffer_req(bh2) && !buffer_uptodate(bh2))
163				sync_failed = 1;
164		}
165		brelse(bh2);
166	}
167	ret = (sync_failed) ? -EIO : 0;
168out_brelse:
169	brelse(bh);
170out:
171	return ret;
172}
173
174static int omfs_write_inode(struct inode *inode, struct writeback_control *wbc)
175{
176	return __omfs_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
177}
178
179int omfs_sync_inode(struct inode *inode)
180{
181	return __omfs_write_inode(inode, 1);
182}
183
184/*
185 * called when an entry is deleted, need to clear the bits in the
186 * bitmaps.
187 */
188static void omfs_evict_inode(struct inode *inode)
189{
190	truncate_inode_pages_final(&inode->i_data);
191	clear_inode(inode);
192
193	if (inode->i_nlink)
194		return;
195
196	if (S_ISREG(inode->i_mode)) {
197		inode->i_size = 0;
198		omfs_shrink_inode(inode);
199	}
200
201	omfs_clear_range(inode->i_sb, inode->i_ino, 2);
202}
203
204struct inode *omfs_iget(struct super_block *sb, ino_t ino)
205{
206	struct omfs_sb_info *sbi = OMFS_SB(sb);
207	struct omfs_inode *oi;
208	struct buffer_head *bh;
209	u64 ctime;
210	unsigned long nsecs;
211	struct inode *inode;
212
213	inode = iget_locked(sb, ino);
214	if (!inode)
215		return ERR_PTR(-ENOMEM);
216	if (!(inode_state_read_once(inode) & I_NEW))
217		return inode;
218
219	bh = omfs_bread(inode->i_sb, ino);
220	if (!bh)
221		goto iget_failed;
222
223	oi = (struct omfs_inode *)bh->b_data;
224
225	/* check self */
226	if (ino != be64_to_cpu(oi->i_head.h_self))
227		goto fail_bh;
228
229	inode->i_uid = sbi->s_uid;
230	inode->i_gid = sbi->s_gid;
231
232	ctime = be64_to_cpu(oi->i_ctime);
233	nsecs = do_div(ctime, 1000) * 1000L;
234
235	inode_set_atime(inode, ctime, nsecs);
236	inode_set_mtime(inode, ctime, nsecs);
237	inode_set_ctime(inode, ctime, nsecs);
238
239	inode->i_mapping->a_ops = &omfs_aops;
240
241	switch (oi->i_type) {
242	case OMFS_DIR:
243		inode->i_mode = S_IFDIR | (S_IRWXUGO & ~sbi->s_dmask);
244		inode->i_op = &omfs_dir_inops;
245		inode->i_fop = &omfs_dir_operations;
246		inode->i_size = sbi->s_sys_blocksize;
247		inc_nlink(inode);
248		break;
249	case OMFS_FILE:
250		inode->i_mode = S_IFREG | (S_IRWXUGO & ~sbi->s_fmask);
251		inode->i_fop = &omfs_file_operations;
252		inode->i_size = be64_to_cpu(oi->i_size);
253		break;
254	}
255	brelse(bh);
256	unlock_new_inode(inode);
257	return inode;
258fail_bh:
259	brelse(bh);
260iget_failed:
261	iget_failed(inode);
262	return ERR_PTR(-EIO);
263}
264
265static void omfs_put_super(struct super_block *sb)
266{
267	struct omfs_sb_info *sbi = OMFS_SB(sb);
268	kfree(sbi->s_imap);
269	kfree(sbi);
270	sb->s_fs_info = NULL;
271}
272
273static int omfs_statfs(struct dentry *dentry, struct kstatfs *buf)
274{
275	struct super_block *s = dentry->d_sb;
276	struct omfs_sb_info *sbi = OMFS_SB(s);
277	u64 id = huge_encode_dev(s->s_bdev->bd_dev);
278
279	buf->f_type = OMFS_MAGIC;
280	buf->f_bsize = sbi->s_blocksize;
281	buf->f_blocks = sbi->s_num_blocks;
282	buf->f_files = sbi->s_num_blocks;
283	buf->f_namelen = OMFS_NAMELEN;
284	buf->f_fsid = u64_to_fsid(id);
285
286	buf->f_bfree = buf->f_bavail = buf->f_ffree =
287		omfs_count_free(s);
288
289	return 0;
290}
291
292/*
293 * Display the mount options in /proc/mounts.
294 */
295static int omfs_show_options(struct seq_file *m, struct dentry *root)
296{
297	struct omfs_sb_info *sbi = OMFS_SB(root->d_sb);
298	umode_t cur_umask = current_umask();
299
300	if (!uid_eq(sbi->s_uid, current_uid()))
301		seq_printf(m, ",uid=%u",
302			   from_kuid_munged(&init_user_ns, sbi->s_uid));
303	if (!gid_eq(sbi->s_gid, current_gid()))
304		seq_printf(m, ",gid=%u",
305			   from_kgid_munged(&init_user_ns, sbi->s_gid));
306
307	if (sbi->s_dmask == sbi->s_fmask) {
308		if (sbi->s_fmask != cur_umask)
309			seq_printf(m, ",umask=%o", sbi->s_fmask);
310	} else {
311		if (sbi->s_dmask != cur_umask)
312			seq_printf(m, ",dmask=%o", sbi->s_dmask);
313		if (sbi->s_fmask != cur_umask)
314			seq_printf(m, ",fmask=%o", sbi->s_fmask);
315	}
316
317	return 0;
318}
319
320static const struct super_operations omfs_sops = {
321	.write_inode	= omfs_write_inode,
322	.evict_inode	= omfs_evict_inode,
323	.put_super	= omfs_put_super,
324	.statfs		= omfs_statfs,
325	.show_options	= omfs_show_options,
326};
327
328/*
329 * For Rio Karma, there is an on-disk free bitmap whose location is
330 * stored in the root block.  For ReplayTV, there is no such free bitmap
331 * so we have to walk the tree.  Both inodes and file data are allocated
332 * from the same map.  This array can be big (300k) so we allocate
333 * in units of the blocksize.
334 */
335static int omfs_get_imap(struct super_block *sb)
336{
337	unsigned int bitmap_size, array_size;
338	int count;
339	struct omfs_sb_info *sbi = OMFS_SB(sb);
340	struct buffer_head *bh;
341	unsigned long **ptr;
342	sector_t block;
343
344	bitmap_size = DIV_ROUND_UP(sbi->s_num_blocks, 8);
345	array_size = DIV_ROUND_UP(bitmap_size, sb->s_blocksize);
346
347	if (sbi->s_bitmap_ino == ~0ULL)
348		goto out;
349
350	sbi->s_imap_size = array_size;
351	sbi->s_imap = kcalloc(array_size, sizeof(unsigned long *), GFP_KERNEL);
352	if (!sbi->s_imap)
353		goto nomem;
354
355	block = clus_to_blk(sbi, sbi->s_bitmap_ino);
356	if (block >= sbi->s_num_blocks)
357		goto nomem;
358
359	ptr = sbi->s_imap;
360	for (count = bitmap_size; count > 0; count -= sb->s_blocksize) {
361		bh = sb_bread(sb, block++);
362		if (!bh)
363			goto nomem_free;
364		*ptr = kmemdup(bh->b_data, sb->s_blocksize, GFP_KERNEL);
365		if (!*ptr) {
366			brelse(bh);
367			goto nomem_free;
368		}
369		if (count < sb->s_blocksize)
370			memset((void *)*ptr + count, 0xff,
371				sb->s_blocksize - count);
372		brelse(bh);
373		ptr++;
374	}
375out:
376	return 0;
377
378nomem_free:
379	for (count = 0; count < array_size; count++)
380		kfree(sbi->s_imap[count]);
381
382	kfree(sbi->s_imap);
383nomem:
384	sbi->s_imap = NULL;
385	sbi->s_imap_size = 0;
386	return -ENOMEM;
387}
388
389struct omfs_mount_options {
390	kuid_t s_uid;
391	kgid_t s_gid;
392	int s_dmask;
393	int s_fmask;
394};
395
396enum {
397	Opt_uid, Opt_gid, Opt_umask, Opt_dmask, Opt_fmask,
398};
399
400static const struct fs_parameter_spec omfs_param_spec[] = {
401	fsparam_uid	("uid",		Opt_uid),
402	fsparam_gid	("gid",		Opt_gid),
403	fsparam_u32oct	("umask",	Opt_umask),
404	fsparam_u32oct	("dmask",	Opt_dmask),
405	fsparam_u32oct	("fmask",	Opt_fmask),
406	{}
407};
408
409static int
410omfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
411{
412	struct omfs_mount_options *opts = fc->fs_private;
413	int token;
414	struct fs_parse_result result;
415
416	/* All options are ignored on remount */
417	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE)
418		return 0;
419
420	token = fs_parse(fc, omfs_param_spec, param, &result);
421	if (token < 0)
422		return token;
423
424	switch (token) {
425	case Opt_uid:
426		opts->s_uid = result.uid;
427		break;
428	case Opt_gid:
429		opts->s_gid = result.gid;
430		break;
431	case Opt_umask:
432		opts->s_fmask = opts->s_dmask = result.uint_32;
433		break;
434	case Opt_dmask:
435		opts->s_dmask = result.uint_32;
436		break;
437	case Opt_fmask:
438		opts->s_fmask = result.uint_32;
439		break;
440	default:
441		return -EINVAL;
442	}
443
444	return 0;
445}
446
447static void
448omfs_set_options(struct omfs_sb_info *sbi, struct omfs_mount_options *opts)
449{
450	sbi->s_uid = opts->s_uid;
451	sbi->s_gid = opts->s_gid;
452	sbi->s_dmask = opts->s_dmask;
453	sbi->s_fmask = opts->s_fmask;
454}
455
456static int omfs_fill_super(struct super_block *sb, struct fs_context *fc)
457{
458	struct buffer_head *bh, *bh2;
459	struct omfs_super_block *omfs_sb;
460	struct omfs_root_block *omfs_rb;
461	struct omfs_sb_info *sbi;
462	struct inode *root;
463	struct omfs_mount_options *parsed_opts = fc->fs_private;
464	int ret = -EINVAL;
465	int silent = fc->sb_flags & SB_SILENT;
466
467	sbi = kzalloc(sizeof(struct omfs_sb_info), GFP_KERNEL);
468	if (!sbi)
469		return -ENOMEM;
470
471	sb->s_fs_info = sbi;
472
473	omfs_set_options(sbi, parsed_opts);
474
475	sb->s_maxbytes = 0xffffffff;
476
477	sb->s_time_gran = NSEC_PER_MSEC;
478	sb->s_time_min = 0;
479	sb->s_time_max = U64_MAX / MSEC_PER_SEC;
480
481	sb_set_blocksize(sb, 0x200);
482
483	bh = sb_bread(sb, 0);
484	if (!bh)
485		goto end;
486
487	omfs_sb = (struct omfs_super_block *)bh->b_data;
488
489	if (omfs_sb->s_magic != cpu_to_be32(OMFS_MAGIC)) {
490		if (!silent)
491			printk(KERN_ERR "omfs: Invalid superblock (%x)\n",
492				   omfs_sb->s_magic);
493		goto out_brelse_bh;
494	}
495	sb->s_magic = OMFS_MAGIC;
496
497	sbi->s_num_blocks = be64_to_cpu(omfs_sb->s_num_blocks);
498	sbi->s_blocksize = be32_to_cpu(omfs_sb->s_blocksize);
499	sbi->s_mirrors = be32_to_cpu(omfs_sb->s_mirrors);
500	sbi->s_root_ino = be64_to_cpu(omfs_sb->s_root_block);
501	sbi->s_sys_blocksize = be32_to_cpu(omfs_sb->s_sys_blocksize);
502	mutex_init(&sbi->s_bitmap_lock);
503
504	if (sbi->s_num_blocks > OMFS_MAX_BLOCKS) {
505		printk(KERN_ERR "omfs: sysblock number (%llx) is out of range\n",
506		       (unsigned long long)sbi->s_num_blocks);
507		goto out_brelse_bh;
508	}
509
510	if (sbi->s_sys_blocksize > PAGE_SIZE) {
511		printk(KERN_ERR "omfs: sysblock size (%d) is out of range\n",
512			sbi->s_sys_blocksize);
513		goto out_brelse_bh;
514	}
515
516	if (sbi->s_blocksize < sbi->s_sys_blocksize ||
517	    sbi->s_blocksize > OMFS_MAX_BLOCK_SIZE) {
518		printk(KERN_ERR "omfs: block size (%d) is out of range\n",
519			sbi->s_blocksize);
520		goto out_brelse_bh;
521	}
522
523	/*
524	 * Use sys_blocksize as the fs block since it is smaller than a
525	 * page while the fs blocksize can be larger.
526	 */
527	sb_set_blocksize(sb, sbi->s_sys_blocksize);
528
529	/*
530	 * ...and the difference goes into a shift.  sys_blocksize is always
531	 * a power of two factor of blocksize.
532	 */
533	sbi->s_block_shift = get_bitmask_order(sbi->s_blocksize) -
534		get_bitmask_order(sbi->s_sys_blocksize);
535
536	bh2 = omfs_bread(sb, be64_to_cpu(omfs_sb->s_root_block));
537	if (!bh2)
538		goto out_brelse_bh;
539
540	omfs_rb = (struct omfs_root_block *)bh2->b_data;
541
542	sbi->s_bitmap_ino = be64_to_cpu(omfs_rb->r_bitmap);
543	sbi->s_clustersize = be32_to_cpu(omfs_rb->r_clustersize);
544
545	if (sbi->s_num_blocks != be64_to_cpu(omfs_rb->r_num_blocks)) {
546		printk(KERN_ERR "omfs: block count discrepancy between "
547			"super and root blocks (%llx, %llx)\n",
548			(unsigned long long)sbi->s_num_blocks,
549			(unsigned long long)be64_to_cpu(omfs_rb->r_num_blocks));
550		goto out_brelse_bh2;
551	}
552
553	if (sbi->s_bitmap_ino != ~0ULL &&
554	    sbi->s_bitmap_ino > sbi->s_num_blocks) {
555		printk(KERN_ERR "omfs: free space bitmap location is corrupt "
556			"(%llx, total blocks %llx)\n",
557			(unsigned long long) sbi->s_bitmap_ino,
558			(unsigned long long) sbi->s_num_blocks);
559		goto out_brelse_bh2;
560	}
561	if (sbi->s_clustersize < 1 ||
562	    sbi->s_clustersize > OMFS_MAX_CLUSTER_SIZE) {
563		printk(KERN_ERR "omfs: cluster size out of range (%d)",
564			sbi->s_clustersize);
565		goto out_brelse_bh2;
566	}
567
568	ret = omfs_get_imap(sb);
569	if (ret)
570		goto out_brelse_bh2;
571
572	sb->s_op = &omfs_sops;
573
574	root = omfs_iget(sb, be64_to_cpu(omfs_rb->r_root_dir));
575	if (IS_ERR(root)) {
576		ret = PTR_ERR(root);
577		goto out_brelse_bh2;
578	}
579
580	sb->s_root = d_make_root(root);
581	if (!sb->s_root) {
582		ret = -ENOMEM;
583		goto out_brelse_bh2;
584	}
585	printk(KERN_DEBUG "omfs: Mounted volume %s\n", omfs_rb->r_name);
586
587	ret = 0;
588out_brelse_bh2:
589	brelse(bh2);
590out_brelse_bh:
591	brelse(bh);
592end:
593	if (ret)
594		kfree(sbi);
595	return ret;
596}
597
598static int omfs_get_tree(struct fs_context *fc)
599{
600	return get_tree_bdev(fc, omfs_fill_super);
601}
602
603static void omfs_free_fc(struct fs_context *fc);
604
605static const struct fs_context_operations omfs_context_ops = {
606	.parse_param	= omfs_parse_param,
607	.get_tree	= omfs_get_tree,
608	.free		= omfs_free_fc,
609};
610
611static int omfs_init_fs_context(struct fs_context *fc)
612{
613	struct omfs_mount_options *opts;
614
615	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
616	if (!opts)
617		return -ENOMEM;
618
619	/* Set mount options defaults */
620	opts->s_uid = current_uid();
621	opts->s_gid = current_gid();
622	opts->s_dmask = opts->s_fmask = current_umask();
623
624	fc->fs_private = opts;
625	fc->ops = &omfs_context_ops;
626
627	return 0;
628}
629
630static void omfs_free_fc(struct fs_context *fc)
631{
632	kfree(fc->fs_private);
633}
634
635static struct file_system_type omfs_fs_type = {
636	.owner		 = THIS_MODULE,
637	.name		 = "omfs",
638	.kill_sb	 = kill_block_super,
639	.fs_flags	 = FS_REQUIRES_DEV,
640	.init_fs_context = omfs_init_fs_context,
641	.parameters	 = omfs_param_spec,
642};
643MODULE_ALIAS_FS("omfs");
644
645static int __init init_omfs_fs(void)
646{
647	return register_filesystem(&omfs_fs_type);
648}
649
650static void __exit exit_omfs_fs(void)
651{
652	unregister_filesystem(&omfs_fs_type);
653}
654
655module_init(init_omfs_fs);
656module_exit(exit_omfs_fs);