xref: /openbmc/linux/fs/efs/super.c (revision 6d99a79c) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * super.c
4  *
5  * Copyright (c) 1999 Al Smith
6  *
7  * Portions derived from work (c) 1995,1996 Christian Vogelgsang.
8  */
9 
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/exportfs.h>
13 #include <linux/slab.h>
14 #include <linux/buffer_head.h>
15 #include <linux/vfs.h>
16 
17 #include "efs.h"
18 #include <linux/efs_vh.h>
19 #include <linux/efs_fs_sb.h>
20 
21 static int efs_statfs(struct dentry *dentry, struct kstatfs *buf);
22 static int efs_fill_super(struct super_block *s, void *d, int silent);
23 
24 static struct dentry *efs_mount(struct file_system_type *fs_type,
25 	int flags, const char *dev_name, void *data)
26 {
27 	return mount_bdev(fs_type, flags, dev_name, data, efs_fill_super);
28 }
29 
30 static void efs_kill_sb(struct super_block *s)
31 {
32 	struct efs_sb_info *sbi = SUPER_INFO(s);
33 	kill_block_super(s);
34 	kfree(sbi);
35 }
36 
37 static struct file_system_type efs_fs_type = {
38 	.owner		= THIS_MODULE,
39 	.name		= "efs",
40 	.mount		= efs_mount,
41 	.kill_sb	= efs_kill_sb,
42 	.fs_flags	= FS_REQUIRES_DEV,
43 };
44 MODULE_ALIAS_FS("efs");
45 
46 static struct pt_types sgi_pt_types[] = {
47 	{0x00,		"SGI vh"},
48 	{0x01,		"SGI trkrepl"},
49 	{0x02,		"SGI secrepl"},
50 	{0x03,		"SGI raw"},
51 	{0x04,		"SGI bsd"},
52 	{SGI_SYSV,	"SGI sysv"},
53 	{0x06,		"SGI vol"},
54 	{SGI_EFS,	"SGI efs"},
55 	{0x08,		"SGI lv"},
56 	{0x09,		"SGI rlv"},
57 	{0x0A,		"SGI xfs"},
58 	{0x0B,		"SGI xfslog"},
59 	{0x0C,		"SGI xlv"},
60 	{0x82,		"Linux swap"},
61 	{0x83,		"Linux native"},
62 	{0,		NULL}
63 };
64 
65 
66 static struct kmem_cache * efs_inode_cachep;
67 
68 static struct inode *efs_alloc_inode(struct super_block *sb)
69 {
70 	struct efs_inode_info *ei;
71 	ei = kmem_cache_alloc(efs_inode_cachep, GFP_KERNEL);
72 	if (!ei)
73 		return NULL;
74 	return &ei->vfs_inode;
75 }
76 
77 static void efs_i_callback(struct rcu_head *head)
78 {
79 	struct inode *inode = container_of(head, struct inode, i_rcu);
80 	kmem_cache_free(efs_inode_cachep, INODE_INFO(inode));
81 }
82 
83 static void efs_destroy_inode(struct inode *inode)
84 {
85 	call_rcu(&inode->i_rcu, efs_i_callback);
86 }
87 
88 static void init_once(void *foo)
89 {
90 	struct efs_inode_info *ei = (struct efs_inode_info *) foo;
91 
92 	inode_init_once(&ei->vfs_inode);
93 }
94 
95 static int __init init_inodecache(void)
96 {
97 	efs_inode_cachep = kmem_cache_create("efs_inode_cache",
98 				sizeof(struct efs_inode_info), 0,
99 				SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
100 				SLAB_ACCOUNT, init_once);
101 	if (efs_inode_cachep == NULL)
102 		return -ENOMEM;
103 	return 0;
104 }
105 
106 static void destroy_inodecache(void)
107 {
108 	/*
109 	 * Make sure all delayed rcu free inodes are flushed before we
110 	 * destroy cache.
111 	 */
112 	rcu_barrier();
113 	kmem_cache_destroy(efs_inode_cachep);
114 }
115 
116 static int efs_remount(struct super_block *sb, int *flags, char *data)
117 {
118 	sync_filesystem(sb);
119 	*flags |= SB_RDONLY;
120 	return 0;
121 }
122 
123 static const struct super_operations efs_superblock_operations = {
124 	.alloc_inode	= efs_alloc_inode,
125 	.destroy_inode	= efs_destroy_inode,
126 	.statfs		= efs_statfs,
127 	.remount_fs	= efs_remount,
128 };
129 
130 static const struct export_operations efs_export_ops = {
131 	.fh_to_dentry	= efs_fh_to_dentry,
132 	.fh_to_parent	= efs_fh_to_parent,
133 	.get_parent	= efs_get_parent,
134 };
135 
136 static int __init init_efs_fs(void) {
137 	int err;
138 	pr_info(EFS_VERSION" - http://aeschi.ch.eu.org/efs/\n");
139 	err = init_inodecache();
140 	if (err)
141 		goto out1;
142 	err = register_filesystem(&efs_fs_type);
143 	if (err)
144 		goto out;
145 	return 0;
146 out:
147 	destroy_inodecache();
148 out1:
149 	return err;
150 }
151 
152 static void __exit exit_efs_fs(void) {
153 	unregister_filesystem(&efs_fs_type);
154 	destroy_inodecache();
155 }
156 
157 module_init(init_efs_fs)
158 module_exit(exit_efs_fs)
159 
160 static efs_block_t efs_validate_vh(struct volume_header *vh) {
161 	int		i;
162 	__be32		cs, *ui;
163 	int		csum;
164 	efs_block_t	sblock = 0; /* shuts up gcc */
165 	struct pt_types	*pt_entry;
166 	int		pt_type, slice = -1;
167 
168 	if (be32_to_cpu(vh->vh_magic) != VHMAGIC) {
169 		/*
170 		 * assume that we're dealing with a partition and allow
171 		 * read_super() to try and detect a valid superblock
172 		 * on the next block.
173 		 */
174 		return 0;
175 	}
176 
177 	ui = ((__be32 *) (vh + 1)) - 1;
178 	for(csum = 0; ui >= ((__be32 *) vh);) {
179 		cs = *ui--;
180 		csum += be32_to_cpu(cs);
181 	}
182 	if (csum) {
183 		pr_warn("SGI disklabel: checksum bad, label corrupted\n");
184 		return 0;
185 	}
186 
187 #ifdef DEBUG
188 	pr_debug("bf: \"%16s\"\n", vh->vh_bootfile);
189 
190 	for(i = 0; i < NVDIR; i++) {
191 		int	j;
192 		char	name[VDNAMESIZE+1];
193 
194 		for(j = 0; j < VDNAMESIZE; j++) {
195 			name[j] = vh->vh_vd[i].vd_name[j];
196 		}
197 		name[j] = (char) 0;
198 
199 		if (name[0]) {
200 			pr_debug("vh: %8s block: 0x%08x size: 0x%08x\n",
201 				name, (int) be32_to_cpu(vh->vh_vd[i].vd_lbn),
202 				(int) be32_to_cpu(vh->vh_vd[i].vd_nbytes));
203 		}
204 	}
205 #endif
206 
207 	for(i = 0; i < NPARTAB; i++) {
208 		pt_type = (int) be32_to_cpu(vh->vh_pt[i].pt_type);
209 		for(pt_entry = sgi_pt_types; pt_entry->pt_name; pt_entry++) {
210 			if (pt_type == pt_entry->pt_type) break;
211 		}
212 #ifdef DEBUG
213 		if (be32_to_cpu(vh->vh_pt[i].pt_nblks)) {
214 			pr_debug("pt %2d: start: %08d size: %08d type: 0x%02x (%s)\n",
215 				 i, (int)be32_to_cpu(vh->vh_pt[i].pt_firstlbn),
216 				 (int)be32_to_cpu(vh->vh_pt[i].pt_nblks),
217 				 pt_type, (pt_entry->pt_name) ?
218 				 pt_entry->pt_name : "unknown");
219 		}
220 #endif
221 		if (IS_EFS(pt_type)) {
222 			sblock = be32_to_cpu(vh->vh_pt[i].pt_firstlbn);
223 			slice = i;
224 		}
225 	}
226 
227 	if (slice == -1) {
228 		pr_notice("partition table contained no EFS partitions\n");
229 #ifdef DEBUG
230 	} else {
231 		pr_info("using slice %d (type %s, offset 0x%x)\n", slice,
232 			(pt_entry->pt_name) ? pt_entry->pt_name : "unknown",
233 			sblock);
234 #endif
235 	}
236 	return sblock;
237 }
238 
239 static int efs_validate_super(struct efs_sb_info *sb, struct efs_super *super) {
240 
241 	if (!IS_EFS_MAGIC(be32_to_cpu(super->fs_magic)))
242 		return -1;
243 
244 	sb->fs_magic     = be32_to_cpu(super->fs_magic);
245 	sb->total_blocks = be32_to_cpu(super->fs_size);
246 	sb->first_block  = be32_to_cpu(super->fs_firstcg);
247 	sb->group_size   = be32_to_cpu(super->fs_cgfsize);
248 	sb->data_free    = be32_to_cpu(super->fs_tfree);
249 	sb->inode_free   = be32_to_cpu(super->fs_tinode);
250 	sb->inode_blocks = be16_to_cpu(super->fs_cgisize);
251 	sb->total_groups = be16_to_cpu(super->fs_ncg);
252 
253 	return 0;
254 }
255 
256 static int efs_fill_super(struct super_block *s, void *d, int silent)
257 {
258 	struct efs_sb_info *sb;
259 	struct buffer_head *bh;
260 	struct inode *root;
261 
262  	sb = kzalloc(sizeof(struct efs_sb_info), GFP_KERNEL);
263 	if (!sb)
264 		return -ENOMEM;
265 	s->s_fs_info = sb;
266 
267 	s->s_magic		= EFS_SUPER_MAGIC;
268 	if (!sb_set_blocksize(s, EFS_BLOCKSIZE)) {
269 		pr_err("device does not support %d byte blocks\n",
270 			EFS_BLOCKSIZE);
271 		return -EINVAL;
272 	}
273 
274 	/* read the vh (volume header) block */
275 	bh = sb_bread(s, 0);
276 
277 	if (!bh) {
278 		pr_err("cannot read volume header\n");
279 		return -EIO;
280 	}
281 
282 	/*
283 	 * if this returns zero then we didn't find any partition table.
284 	 * this isn't (yet) an error - just assume for the moment that
285 	 * the device is valid and go on to search for a superblock.
286 	 */
287 	sb->fs_start = efs_validate_vh((struct volume_header *) bh->b_data);
288 	brelse(bh);
289 
290 	if (sb->fs_start == -1) {
291 		return -EINVAL;
292 	}
293 
294 	bh = sb_bread(s, sb->fs_start + EFS_SUPER);
295 	if (!bh) {
296 		pr_err("cannot read superblock\n");
297 		return -EIO;
298 	}
299 
300 	if (efs_validate_super(sb, (struct efs_super *) bh->b_data)) {
301 #ifdef DEBUG
302 		pr_warn("invalid superblock at block %u\n",
303 			sb->fs_start + EFS_SUPER);
304 #endif
305 		brelse(bh);
306 		return -EINVAL;
307 	}
308 	brelse(bh);
309 
310 	if (!sb_rdonly(s)) {
311 #ifdef DEBUG
312 		pr_info("forcing read-only mode\n");
313 #endif
314 		s->s_flags |= SB_RDONLY;
315 	}
316 	s->s_op   = &efs_superblock_operations;
317 	s->s_export_op = &efs_export_ops;
318 	root = efs_iget(s, EFS_ROOTINODE);
319 	if (IS_ERR(root)) {
320 		pr_err("get root inode failed\n");
321 		return PTR_ERR(root);
322 	}
323 
324 	s->s_root = d_make_root(root);
325 	if (!(s->s_root)) {
326 		pr_err("get root dentry failed\n");
327 		return -ENOMEM;
328 	}
329 
330 	return 0;
331 }
332 
333 static int efs_statfs(struct dentry *dentry, struct kstatfs *buf) {
334 	struct super_block *sb = dentry->d_sb;
335 	struct efs_sb_info *sbi = SUPER_INFO(sb);
336 	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
337 
338 	buf->f_type    = EFS_SUPER_MAGIC;	/* efs magic number */
339 	buf->f_bsize   = EFS_BLOCKSIZE;		/* blocksize */
340 	buf->f_blocks  = sbi->total_groups *	/* total data blocks */
341 			(sbi->group_size - sbi->inode_blocks);
342 	buf->f_bfree   = sbi->data_free;	/* free data blocks */
343 	buf->f_bavail  = sbi->data_free;	/* free blocks for non-root */
344 	buf->f_files   = sbi->total_groups *	/* total inodes */
345 			sbi->inode_blocks *
346 			(EFS_BLOCKSIZE / sizeof(struct efs_dinode));
347 	buf->f_ffree   = sbi->inode_free;	/* free inodes */
348 	buf->f_fsid.val[0] = (u32)id;
349 	buf->f_fsid.val[1] = (u32)(id >> 32);
350 	buf->f_namelen = EFS_MAXNAMELEN;	/* max filename length */
351 
352 	return 0;
353 }
354 
355