1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* linux/fs/ufs/super.c
4	*
5	* Copyright (C) 1998
6	* Daniel Pirkl <daniel.pirkl@email.cz>
7	* Charles University, Faculty of Mathematics and Physics
8	*/
9
10	/* Derived from
11	*
12	* linux/fs/ext2/super.c
13	*
14	* Copyright (C) 1992, 1993, 1994, 1995
15	* Remy Card (card@masi.ibp.fr)
16	* Laboratoire MASI - Institut Blaise Pascal
17	* Universite Pierre et Marie Curie (Paris VI)
18	*
19	* from
20	*
21	* linux/fs/minix/inode.c
22	*
23	* Copyright (C) 1991, 1992 Linus Torvalds
24	*
25	* Big-endian to little-endian byte-swapping/bitmaps by
26	* David S. Miller (davem@caip.rutgers.edu), 1995
27	*/
28
29	/*
30	* Inspired by
31	*
32	* linux/fs/ufs/super.c
33	*
34	* Copyright (C) 1996
35	* Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
36	* Laboratory for Computer Science Research Computing Facility
37	* Rutgers, The State University of New Jersey
38	*
39	* Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
40	*
41	* Kernel module support added on 96/04/26 by
42	* Stefan Reinauer <stepan@home.culture.mipt.ru>
43	*
44	* Module usage counts added on 96/04/29 by
45	* Gertjan van Wingerde <gwingerde@gmail.com>
46	*
47	* Clean swab support on 19970406 by
48	* Francois-Rene Rideau <fare@tunes.org>
49	*
50	* 4.4BSD (FreeBSD) support added on February 1st 1998 by
51	* Niels Kristian Bech Jensen <nkbj@image.dk> partially based
52	* on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
53	*
54	* NeXTstep support added on February 5th 1998 by
55	* Niels Kristian Bech Jensen <nkbj@image.dk>.
56	*
57	* write support Daniel Pirkl <daniel.pirkl@email.cz> 1998
58	*
59	* HP/UX hfs filesystem support added by
60	* Martin K. Petersen <mkp@mkp.net>, August 1999
61	*
62	* UFS2 (of FreeBSD 5.x) support added by
63	* Niraj Kumar <niraj17@iitbombay.org>, Jan 2004
64	*
65	* UFS2 write support added by
66	* Evgeniy Dushistov <dushistov@mail.ru>, 2007
67	*/
68
69	#include <linux/exportfs.h>
70	#include <linux/module.h>
71	#include <linux/bitops.h>
72
73	#include <linux/stdarg.h>
74
75	#include <linux/uaccess.h>
76
77	#include <linux/errno.h>
78	#include <linux/fs.h>
79	#include <linux/slab.h>
80	#include <linux/time.h>
81	#include <linux/stat.h>
82	#include <linux/string.h>
83	#include <linux/blkdev.h>
84	#include <linux/backing-dev.h>
85	#include <linux/init.h>
86	#include <linux/fs_context.h>
87	#include <linux/fs_parser.h>
88	#include <linux/buffer_head.h>
89	#include <linux/vfs.h>
90	#include <linux/log2.h>
91	#include <linux/seq_file.h>
92	#include <linux/iversion.h>
93
94	#include "ufs_fs.h"
95	#include "ufs.h"
96	#include "swab.h"
97	#include "util.h"
98
99	static struct inode *ufs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
100	{
101	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
102	struct inode *inode;
103
104	if (ino < UFS_ROOTINO || ino > (u64)uspi->s_ncg * uspi->s_ipg)
105	return ERR_PTR(error: -ESTALE);
106
107	inode = ufs_iget(sb, ino);
108	if (IS_ERR(ptr: inode))
109	return ERR_CAST(ptr: inode);
110	if (generation && inode->i_generation != generation) {
111	iput(inode);
112	return ERR_PTR(error: -ESTALE);
113	}
114	return inode;
115	}
116
117	static struct dentry *ufs_fh_to_dentry(struct super_block *sb, struct fid *fid,
118	int fh_len, int fh_type)
119	{
120	return generic_fh_to_dentry(sb, fid, fh_len, fh_type, get_inode: ufs_nfs_get_inode);
121	}
122
123	static struct dentry *ufs_fh_to_parent(struct super_block *sb, struct fid *fid,
124	int fh_len, int fh_type)
125	{
126	return generic_fh_to_parent(sb, fid, fh_len, fh_type, get_inode: ufs_nfs_get_inode);
127	}
128
129	static struct dentry *ufs_get_parent(struct dentry *child)
130	{
131	ino_t ino;
132
133	ino = ufs_inode_by_name(d_inode(dentry: child), &dotdot_name);
134	if (!ino)
135	return ERR_PTR(error: -ENOENT);
136	return d_obtain_alias(ufs_iget(child->d_sb, ino));
137	}
138
139	static const struct export_operations ufs_export_ops = {
140	.encode_fh = generic_encode_ino32_fh,
141	.fh_to_dentry = ufs_fh_to_dentry,
142	.fh_to_parent = ufs_fh_to_parent,
143	.get_parent = ufs_get_parent,
144	};
145
146	#ifdef CONFIG_UFS_DEBUG
147	/*
148	* Print contents of ufs_super_block, useful for debugging
149	*/
150	static void ufs_print_super_stuff(struct super_block *sb,
151	struct ufs_super_block_first *usb1,
152	struct ufs_super_block_second *usb2,
153	struct ufs_super_block_third *usb3)
154	{
155	u32 magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic);
156
157	pr_debug("ufs_print_super_stuff\n");
158	pr_debug(" magic: 0x%x\n", magic);
159	if (fs32_to_cpu(sbp: sb, n: usb3->fs_magic) == UFS2_MAGIC) {
160	pr_debug(" fs_size: %llu\n", (unsigned long long)
161	fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
162	pr_debug(" fs_dsize: %llu\n", (unsigned long long)
163	fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
164	pr_debug(" bsize: %u\n",
165	fs32_to_cpu(sb, usb1->fs_bsize));
166	pr_debug(" fsize: %u\n",
167	fs32_to_cpu(sb, usb1->fs_fsize));
168	pr_debug(" fs_volname: %s\n", usb2->fs_un.fs_u2.fs_volname);
169	pr_debug(" fs_sblockloc: %llu\n", (unsigned long long)
170	fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
171	pr_debug(" cs_ndir(No of dirs): %llu\n", (unsigned long long)
172	fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
173	pr_debug(" cs_nbfree(No of free blocks): %llu\n",
174	(unsigned long long)
175	fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
176	pr_info(" cs_nifree(Num of free inodes): %llu\n",
177	(unsigned long long)
178	fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree));
179	pr_info(" cs_nffree(Num of free frags): %llu\n",
180	(unsigned long long)
181	fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
182	pr_info(" fs_maxsymlinklen: %u\n",
183	fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
184	} else {
185	pr_debug(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
186	pr_debug(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
187	pr_debug(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
188	pr_debug(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
189	pr_debug(" cgoffset: %u\n",
190	fs32_to_cpu(sb, usb1->fs_cgoffset));
191	pr_debug(" ~cgmask: 0x%x\n",
192	~fs32_to_cpu(sb, usb1->fs_cgmask));
193	pr_debug(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
194	pr_debug(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
195	pr_debug(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
196	pr_debug(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
197	pr_debug(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
198	pr_debug(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
199	pr_debug(" fragshift: %u\n",
200	fs32_to_cpu(sb, usb1->fs_fragshift));
201	pr_debug(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
202	pr_debug(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
203	pr_debug(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
204	pr_debug(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
205	pr_debug(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
206	pr_debug(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
207	pr_debug(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
208	pr_debug(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
209	pr_debug(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
210	pr_debug(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
211	pr_debug(" fstodb: %u\n",
212	fs32_to_cpu(sb, usb1->fs_fsbtodb));
213	pr_debug(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
214	pr_debug(" ndir %u\n",
215	fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
216	pr_debug(" nifree %u\n",
217	fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
218	pr_debug(" nbfree %u\n",
219	fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
220	pr_debug(" nffree %u\n",
221	fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
222	}
223	pr_debug("\n");
224	}
225
226	/*
227	* Print contents of ufs_cylinder_group, useful for debugging
228	*/
229	static void ufs_print_cylinder_stuff(struct super_block *sb,
230	struct ufs_cylinder_group *cg)
231	{
232	pr_debug("\nufs_print_cylinder_stuff\n");
233	pr_debug("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
234	pr_debug(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
235	pr_debug(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
236	pr_debug(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
237	pr_debug(" ncyl: %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
238	pr_debug(" niblk: %u\n", fs16_to_cpu(sb, cg->cg_niblk));
239	pr_debug(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
240	pr_debug(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
241	pr_debug(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
242	pr_debug(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
243	pr_debug(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
244	pr_debug(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
245	pr_debug(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
246	pr_debug(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
247	pr_debug(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
248	fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
249	fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
250	fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
251	fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
252	pr_debug(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
253	pr_debug(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
254	pr_debug(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
255	pr_debug(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
256	pr_debug(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
257	pr_debug(" clustersumoff %u\n",
258	fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
259	pr_debug(" clusteroff %u\n",
260	fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
261	pr_debug(" nclusterblks %u\n",
262	fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
263	pr_debug("\n");
264	}
265	#else
266	# define ufs_print_super_stuff(sb, usb1, usb2, usb3) /**/
267	# define ufs_print_cylinder_stuff(sb, cg) /**/
268	#endif /* CONFIG_UFS_DEBUG */
269
270	static const struct super_operations ufs_super_ops;
271
272	void ufs_error (struct super_block * sb, const char * function,
273	const char * fmt, ...)
274	{
275	struct ufs_sb_private_info * uspi;
276	struct ufs_super_block_first * usb1;
277	struct va_format vaf;
278	va_list args;
279
280	uspi = UFS_SB(sb)->s_uspi;
281	usb1 = ubh_get_usb_first(uspi);
282
283	if (!sb_rdonly(sb)) {
284	usb1->fs_clean = UFS_FSBAD;
285	ubh_mark_buffer_dirty(USPI_UBH(spi: uspi));
286	ufs_mark_sb_dirty(sb);
287	sb->s_flags |= SB_RDONLY;
288	}
289	va_start(args, fmt);
290	vaf.fmt = fmt;
291	vaf.va = &args;
292	switch (UFS_SB(sb)->s_on_err) {
293	case UFS_MOUNT_ONERROR_PANIC:
294	panic(fmt: "panic (device %s): %s: %pV\n",
295	sb->s_id, function, &vaf);
296
297	case UFS_MOUNT_ONERROR_LOCK:
298	case UFS_MOUNT_ONERROR_UMOUNT:
299	case UFS_MOUNT_ONERROR_REPAIR:
300	pr_crit("error (device %s): %s: %pV\n",
301	sb->s_id, function, &vaf);
302	}
303	va_end(args);
304	}
305
306	void ufs_panic (struct super_block * sb, const char * function,
307	const char * fmt, ...)
308	{
309	struct ufs_sb_private_info * uspi;
310	struct ufs_super_block_first * usb1;
311	struct va_format vaf;
312	va_list args;
313
314	uspi = UFS_SB(sb)->s_uspi;
315	usb1 = ubh_get_usb_first(uspi);
316
317	if (!sb_rdonly(sb)) {
318	usb1->fs_clean = UFS_FSBAD;
319	ubh_mark_buffer_dirty(USPI_UBH(spi: uspi));
320	ufs_mark_sb_dirty(sb);
321	}
322	va_start(args, fmt);
323	vaf.fmt = fmt;
324	vaf.va = &args;
325	sb->s_flags |= SB_RDONLY;
326	pr_crit("panic (device %s): %s: %pV\n",
327	sb->s_id, function, &vaf);
328	va_end(args);
329	}
330
331	void ufs_warning (struct super_block * sb, const char * function,
332	const char * fmt, ...)
333	{
334	struct va_format vaf;
335	va_list args;
336
337	va_start(args, fmt);
338	vaf.fmt = fmt;
339	vaf.va = &args;
340	pr_warn("(device %s): %s: %pV\n",
341	sb->s_id, function, &vaf);
342	va_end(args);
343	}
344
345	enum { Opt_type, Opt_onerror };
346
347	static const struct constant_table ufs_param_ufstype[] = {
348	{"old", UFS_MOUNT_UFSTYPE_OLD},
349	{"sunx86", UFS_MOUNT_UFSTYPE_SUNx86},
350	{"sun", UFS_MOUNT_UFSTYPE_SUN},
351	{"sunos", UFS_MOUNT_UFSTYPE_SUNOS},
352	{"44bsd", UFS_MOUNT_UFSTYPE_44BSD},
353	{"ufs2", UFS_MOUNT_UFSTYPE_UFS2},
354	{"5xbsd", UFS_MOUNT_UFSTYPE_UFS2},
355	{"hp", UFS_MOUNT_UFSTYPE_HP},
356	{"nextstep-cd", UFS_MOUNT_UFSTYPE_NEXTSTEP_CD},
357	{"nextstep", UFS_MOUNT_UFSTYPE_NEXTSTEP},
358	{"openstep", UFS_MOUNT_UFSTYPE_OPENSTEP},
359	{}
360	};
361
362	static const struct constant_table ufs_param_onerror[] = {
363	{"panic", UFS_MOUNT_ONERROR_PANIC},
364	{"lock", UFS_MOUNT_ONERROR_LOCK},
365	{"umount", UFS_MOUNT_ONERROR_UMOUNT},
366	{"repair", UFS_MOUNT_ONERROR_REPAIR},
367	{}
368	};
369
370	static const struct fs_parameter_spec ufs_param_spec[] = {
371	fsparam_enum ("ufstype", Opt_type, ufs_param_ufstype),
372	fsparam_enum ("onerror", Opt_onerror, ufs_param_onerror),
373	{}
374	};
375
376	struct ufs_fs_context {
377	unsigned int flavour, on_err;
378	};
379
380	static int ufs_parse_param(struct fs_context *fc, struct fs_parameter *param)
381	{
382	struct ufs_fs_context *ctx = fc->fs_private;
383	struct fs_parse_result result;
384	int opt;
385
386	UFSD("ENTER\n");
387
388	opt = fs_parse(fc, desc: ufs_param_spec, param, result: &result);
389	if (opt < 0)
390	return opt;
391
392	switch (opt) {
393	case Opt_type:
394	if (ctx->flavour == result.uint_32) /* no-op */
395	return 0;
396	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
397	pr_err("ufstype can't be changed during remount\n");
398	return -EINVAL;
399	}
400	if (!ctx->flavour) {
401	pr_err("conflicting ufstype options\n");
402	return -EINVAL;
403	}
404	ctx->flavour = result.uint_32;
405	break;
406	case Opt_onerror:
407	ctx->on_err = result.uint_32;
408	break;
409	default:
410	return -EINVAL;
411	}
412	return 0;
413	}
414
415	/*
416	* Different types of UFS hold fs_cstotal in different
417	* places, and use different data structure for it.
418	* To make things simpler we just copy fs_cstotal to ufs_sb_private_info
419	*/
420	static void ufs_setup_cstotal(struct super_block *sb)
421	{
422	struct ufs_sb_info *sbi = UFS_SB(sb);
423	struct ufs_sb_private_info *uspi = sbi->s_uspi;
424	struct ufs_super_block_first *usb1;
425	struct ufs_super_block_second *usb2;
426	struct ufs_super_block_third *usb3;
427	unsigned mtype = sbi->s_flavour;
428
429	UFSD("ENTER, mtype=%u\n", mtype);
430	usb1 = ubh_get_usb_first(uspi);
431	usb2 = ubh_get_usb_second(uspi);
432	usb3 = ubh_get_usb_third(uspi);
433
434	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
435	(usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||
436	mtype == UFS_MOUNT_UFSTYPE_UFS2) {
437	/*we have statistic in different place, then usual*/
438	uspi->cs_total.cs_ndir = fs64_to_cpu(sbp: sb, n: usb2->fs_un.fs_u2.cs_ndir);
439	uspi->cs_total.cs_nbfree = fs64_to_cpu(sbp: sb, n: usb2->fs_un.fs_u2.cs_nbfree);
440	uspi->cs_total.cs_nifree = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.cs_nifree);
441	uspi->cs_total.cs_nffree = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.cs_nffree);
442	} else {
443	uspi->cs_total.cs_ndir = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_ndir);
444	uspi->cs_total.cs_nbfree = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_nbfree);
445	uspi->cs_total.cs_nifree = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_nifree);
446	uspi->cs_total.cs_nffree = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_nffree);
447	}
448	UFSD("EXIT\n");
449	}
450
451	/*
452	* Read on-disk structures associated with cylinder groups
453	*/
454	static int ufs_read_cylinder_structures(struct super_block *sb)
455	{
456	struct ufs_sb_info *sbi = UFS_SB(sb);
457	struct ufs_sb_private_info *uspi = sbi->s_uspi;
458	unsigned char * base, * space;
459	unsigned size, blks, i;
460
461	UFSD("ENTER\n");
462
463	/*
464	* Read cs structures from (usually) first data block
465	* on the device.
466	*/
467	size = uspi->s_cssize;
468	blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
469	base = space = kmalloc(size, GFP_NOFS);
470	if (!base)
471	goto failed;
472	sbi->s_csp = (struct ufs_csum *)space;
473	for (i = 0; i < blks; i++) {
474	struct buffer_head *bh = sb_bread(sb, block: uspi->s_csaddr + i);
475	if (!bh)
476	goto failed;
477	memcpy(space, bh->b_data, uspi->s_fsize);
478	space += uspi->s_fsize;
479	brelse (bh);
480	}
481
482	/*
483	* Read cylinder group (we read only first fragment from block
484	* at this time) and prepare internal data structures for cg caching.
485	*/
486	sbi->s_ucg = kmalloc_array(uspi->s_ncg, sizeof(struct buffer_head *),
487	GFP_NOFS);
488	if (!sbi->s_ucg)
489	goto failed;
490	for (i = 0; i < uspi->s_ncg; i++)
491	sbi->s_ucg[i] = NULL;
492	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
493	sbi->s_ucpi[i] = NULL;
494	sbi->s_cgno[i] = UFS_CGNO_EMPTY;
495	}
496	for (i = 0; i < uspi->s_ncg; i++) {
497	UFSD("read cg %u\n", i);
498	if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
499	goto failed;
500	if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
501	goto failed;
502
503	ufs_print_cylinder_stuff(sb, cg: (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
504	}
505	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
506	if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))
507	goto failed;
508	sbi->s_cgno[i] = UFS_CGNO_EMPTY;
509	}
510	sbi->s_cg_loaded = 0;
511	UFSD("EXIT\n");
512	return 1;
513
514	failed:
515	kfree (objp: base);
516	if (sbi->s_ucg) {
517	for (i = 0; i < uspi->s_ncg; i++)
518	if (sbi->s_ucg[i])
519	brelse (bh: sbi->s_ucg[i]);
520	kfree (objp: sbi->s_ucg);
521	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
522	kfree (objp: sbi->s_ucpi[i]);
523	}
524	UFSD("EXIT (FAILED)\n");
525	return 0;
526	}
527
528	/*
529	* Sync our internal copy of fs_cstotal with disk
530	*/
531	static void ufs_put_cstotal(struct super_block *sb)
532	{
533	unsigned mtype = UFS_SB(sb)->s_flavour;
534	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
535	struct ufs_super_block_first *usb1;
536	struct ufs_super_block_second *usb2;
537	struct ufs_super_block_third *usb3;
538
539	UFSD("ENTER\n");
540	usb1 = ubh_get_usb_first(uspi);
541	usb2 = ubh_get_usb_second(uspi);
542	usb3 = ubh_get_usb_third(uspi);
543
544	if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
545	/*we have statistic in different place, then usual*/
546	usb2->fs_un.fs_u2.cs_ndir =
547	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_ndir);
548	usb2->fs_un.fs_u2.cs_nbfree =
549	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nbfree);
550	usb3->fs_un1.fs_u2.cs_nifree =
551	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nifree);
552	usb3->fs_un1.fs_u2.cs_nffree =
553	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nffree);
554	goto out;
555	}
556
557	if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
558	(usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
559	/* store stats in both old and new places */
560	usb2->fs_un.fs_u2.cs_ndir =
561	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_ndir);
562	usb2->fs_un.fs_u2.cs_nbfree =
563	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nbfree);
564	usb3->fs_un1.fs_u2.cs_nifree =
565	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nifree);
566	usb3->fs_un1.fs_u2.cs_nffree =
567	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nffree);
568	}
569	usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_ndir);
570	usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_nbfree);
571	usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_nifree);
572	usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_nffree);
573	out:
574	ubh_mark_buffer_dirty(USPI_UBH(spi: uspi));
575	ufs_print_super_stuff(sb, usb1, usb2, usb3);
576	UFSD("EXIT\n");
577	}
578
579	/**
580	* ufs_put_super_internal() - put on-disk intrenal structures
581	* @sb: pointer to super_block structure
582	* Put on-disk structures associated with cylinder groups
583	* and write them back to disk, also update cs_total on disk
584	*/
585	static void ufs_put_super_internal(struct super_block *sb)
586	{
587	struct ufs_sb_info *sbi = UFS_SB(sb);
588	struct ufs_sb_private_info *uspi = sbi->s_uspi;
589	unsigned char * base, * space;
590	unsigned blks, size, i;
591
592
593	UFSD("ENTER\n");
594
595	ufs_put_cstotal(sb);
596	size = uspi->s_cssize;
597	blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
598	base = space = (char*) sbi->s_csp;
599	for (i = 0; i < blks; i++, space += uspi->s_fsize) {
600	struct buffer_head *bh = sb_bread(sb, block: uspi->s_csaddr + i);
601
602	if (unlikely(!bh)) { // better than an oops...
603	ufs_panic(sb, function: __func__,
604	fmt: "can't write part of cylinder group summary");
605	continue;
606	}
607	memcpy(bh->b_data, space, uspi->s_fsize);
608	mark_buffer_dirty(bh);
609	brelse(bh);
610	}
611	for (i = 0; i < sbi->s_cg_loaded; i++) {
612	ufs_put_cylinder (sb, i);
613	kfree (objp: sbi->s_ucpi[i]);
614	}
615	for (; i < UFS_MAX_GROUP_LOADED; i++)
616	kfree (objp: sbi->s_ucpi[i]);
617	for (i = 0; i < uspi->s_ncg; i++)
618	brelse (bh: sbi->s_ucg[i]);
619	kfree (objp: sbi->s_ucg);
620	kfree (objp: base);
621
622	UFSD("EXIT\n");
623	}
624
625	static int ufs_sync_fs(struct super_block *sb, int wait)
626	{
627	struct ufs_sb_private_info * uspi;
628	struct ufs_super_block_first * usb1;
629	struct ufs_super_block_third * usb3;
630	unsigned flags;
631
632	mutex_lock(&UFS_SB(sb)->s_lock);
633
634	UFSD("ENTER\n");
635
636	flags = UFS_SB(sb)->s_flags;
637	uspi = UFS_SB(sb)->s_uspi;
638	usb1 = ubh_get_usb_first(uspi);
639	usb3 = ubh_get_usb_third(uspi);
640
641	usb1->fs_time = ufs_get_seconds(sbp: sb);
642	if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
643	(flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
644	(flags & UFS_ST_MASK) == UFS_ST_SUNx86)
645	ufs_set_fs_state(sb, usb1, usb3,
646	UFS_FSOK - fs32_to_cpu(sbp: sb, n: usb1->fs_time));
647	ufs_put_cstotal(sb);
648
649	UFSD("EXIT\n");
650	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
651
652	return 0;
653	}
654
655	static void delayed_sync_fs(struct work_struct *work)
656	{
657	struct ufs_sb_info *sbi;
658
659	sbi = container_of(work, struct ufs_sb_info, sync_work.work);
660
661	spin_lock(lock: &sbi->work_lock);
662	sbi->work_queued = 0;
663	spin_unlock(lock: &sbi->work_lock);
664
665	ufs_sync_fs(sb: sbi->sb, wait: 1);
666	}
667
668	void ufs_mark_sb_dirty(struct super_block *sb)
669	{
670	struct ufs_sb_info *sbi = UFS_SB(sb);
671	unsigned long delay;
672
673	spin_lock(lock: &sbi->work_lock);
674	if (!sbi->work_queued) {
675	delay = msecs_to_jiffies(m: dirty_writeback_interval * 10);
676	queue_delayed_work(wq: system_long_wq, dwork: &sbi->sync_work, delay);
677	sbi->work_queued = 1;
678	}
679	spin_unlock(lock: &sbi->work_lock);
680	}
681
682	static void ufs_put_super(struct super_block *sb)
683	{
684	struct ufs_sb_info * sbi = UFS_SB(sb);
685
686	UFSD("ENTER\n");
687
688	if (!sb_rdonly(sb))
689	ufs_put_super_internal(sb);
690	cancel_delayed_work_sync(dwork: &sbi->sync_work);
691
692	ubh_brelse_uspi (sbi->s_uspi);
693	kfree (objp: sbi->s_uspi);
694	kfree (objp: sbi);
695	sb->s_fs_info = NULL;
696	UFSD("EXIT\n");
697	return;
698	}
699
700	static u64 ufs_max_bytes(struct super_block *sb)
701	{
702	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
703	int bits = uspi->s_apbshift;
704	u64 res;
705
706	if (bits > 21)
707	res = ~0ULL;
708	else
709	res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
710	(1LL << (3*bits));
711
712	if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
713	return MAX_LFS_FILESIZE;
714	return res << uspi->s_bshift;
715	}
716
717	static int ufs_fill_super(struct super_block *sb, struct fs_context *fc)
718	{
719	struct ufs_fs_context *ctx = fc->fs_private;
720	int silent = fc->sb_flags & SB_SILENT;
721	struct ufs_sb_info * sbi;
722	struct ufs_sb_private_info * uspi;
723	struct ufs_super_block_first * usb1;
724	struct ufs_super_block_second * usb2;
725	struct ufs_super_block_third * usb3;
726	struct ufs_buffer_head * ubh;
727	struct inode *inode;
728	unsigned block_size, super_block_size;
729	unsigned flags;
730	unsigned super_block_offset;
731	unsigned maxsymlen;
732	int ret = -EINVAL;
733
734	uspi = NULL;
735	ubh = NULL;
736	flags = 0;
737
738	UFSD("ENTER\n");
739
740	#ifndef CONFIG_UFS_FS_WRITE
741	if (!sb_rdonly(sb)) {
742	pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
743	return -EROFS;
744	}
745	#endif
746
747	sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
748	if (!sbi)
749	goto failed_nomem;
750	sb->s_fs_info = sbi;
751	sbi->sb = sb;
752
753	UFSD("flag %u\n", (int)(sb_rdonly(sb)));
754
755	mutex_init(&sbi->s_lock);
756	spin_lock_init(&sbi->work_lock);
757	INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
758
759	sbi->s_flavour = ctx->flavour;
760	sbi->s_on_err = ctx->on_err;
761
762	if (!sbi->s_flavour) {
763	if (!silent)
764	pr_err("You didn't specify the type of your ufs filesystem\n\n"
765	"mount -t ufs -o ufstype="
766	"sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
767	">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
768	"default is ufstype=old\n");
769	sbi->s_flavour = UFS_MOUNT_UFSTYPE_OLD;
770	}
771
772	uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
773	sbi->s_uspi = uspi;
774	if (!uspi)
775	goto failed;
776	uspi->s_dirblksize = UFS_SECTOR_SIZE;
777	super_block_offset=UFS_SBLOCK;
778
779	sb->s_maxbytes = MAX_LFS_FILESIZE;
780
781	sb->s_time_gran = NSEC_PER_SEC;
782	sb->s_time_min = S32_MIN;
783	sb->s_time_max = S32_MAX;
784
785	switch (sbi->s_flavour) {
786	case UFS_MOUNT_UFSTYPE_44BSD:
787	UFSD("ufstype=44bsd\n");
788	uspi->s_fsize = block_size = 512;
789	uspi->s_fmask = ~(512 - 1);
790	uspi->s_fshift = 9;
791	uspi->s_sbsize = super_block_size = 1536;
792	uspi->s_sbbase = 0;
793	flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
794	break;
795	case UFS_MOUNT_UFSTYPE_UFS2:
796	UFSD("ufstype=ufs2\n");
797	super_block_offset=SBLOCK_UFS2;
798	uspi->s_fsize = block_size = 512;
799	uspi->s_fmask = ~(512 - 1);
800	uspi->s_fshift = 9;
801	uspi->s_sbsize = super_block_size = 1536;
802	uspi->s_sbbase = 0;
803	sb->s_time_gran = 1;
804	sb->s_time_min = S64_MIN;
805	sb->s_time_max = S64_MAX;
806	flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
807	break;
808
809	case UFS_MOUNT_UFSTYPE_SUN:
810	UFSD("ufstype=sun\n");
811	uspi->s_fsize = block_size = 1024;
812	uspi->s_fmask = ~(1024 - 1);
813	uspi->s_fshift = 10;
814	uspi->s_sbsize = super_block_size = 2048;
815	uspi->s_sbbase = 0;
816	uspi->s_maxsymlinklen = 0; /* Not supported on disk */
817	flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
818	break;
819
820	case UFS_MOUNT_UFSTYPE_SUNOS:
821	UFSD("ufstype=sunos\n");
822	uspi->s_fsize = block_size = 1024;
823	uspi->s_fmask = ~(1024 - 1);
824	uspi->s_fshift = 10;
825	uspi->s_sbsize = 2048;
826	super_block_size = 2048;
827	uspi->s_sbbase = 0;
828	uspi->s_maxsymlinklen = 0; /* Not supported on disk */
829	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
830	break;
831
832	case UFS_MOUNT_UFSTYPE_SUNx86:
833	UFSD("ufstype=sunx86\n");
834	uspi->s_fsize = block_size = 1024;
835	uspi->s_fmask = ~(1024 - 1);
836	uspi->s_fshift = 10;
837	uspi->s_sbsize = super_block_size = 2048;
838	uspi->s_sbbase = 0;
839	uspi->s_maxsymlinklen = 0; /* Not supported on disk */
840	flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
841	break;
842
843	case UFS_MOUNT_UFSTYPE_OLD:
844	UFSD("ufstype=old\n");
845	uspi->s_fsize = block_size = 1024;
846	uspi->s_fmask = ~(1024 - 1);
847	uspi->s_fshift = 10;
848	uspi->s_sbsize = super_block_size = 2048;
849	uspi->s_sbbase = 0;
850	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
851	if (!sb_rdonly(sb)) {
852	if (!silent)
853	pr_info("ufstype=old is supported read-only\n");
854	sb->s_flags |= SB_RDONLY;
855	}
856	break;
857
858	case UFS_MOUNT_UFSTYPE_NEXTSTEP:
859	UFSD("ufstype=nextstep\n");
860	uspi->s_fsize = block_size = 1024;
861	uspi->s_fmask = ~(1024 - 1);
862	uspi->s_fshift = 10;
863	uspi->s_sbsize = super_block_size = 2048;
864	uspi->s_sbbase = 0;
865	uspi->s_dirblksize = 1024;
866	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
867	if (!sb_rdonly(sb)) {
868	if (!silent)
869	pr_info("ufstype=nextstep is supported read-only\n");
870	sb->s_flags |= SB_RDONLY;
871	}
872	break;
873
874	case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
875	UFSD("ufstype=nextstep-cd\n");
876	uspi->s_fsize = block_size = 2048;
877	uspi->s_fmask = ~(2048 - 1);
878	uspi->s_fshift = 11;
879	uspi->s_sbsize = super_block_size = 2048;
880	uspi->s_sbbase = 0;
881	uspi->s_dirblksize = 1024;
882	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
883	if (!sb_rdonly(sb)) {
884	if (!silent)
885	pr_info("ufstype=nextstep-cd is supported read-only\n");
886	sb->s_flags |= SB_RDONLY;
887	}
888	break;
889
890	case UFS_MOUNT_UFSTYPE_OPENSTEP:
891	UFSD("ufstype=openstep\n");
892	uspi->s_fsize = block_size = 1024;
893	uspi->s_fmask = ~(1024 - 1);
894	uspi->s_fshift = 10;
895	uspi->s_sbsize = super_block_size = 2048;
896	uspi->s_sbbase = 0;
897	uspi->s_dirblksize = 1024;
898	flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
899	if (!sb_rdonly(sb)) {
900	if (!silent)
901	pr_info("ufstype=openstep is supported read-only\n");
902	sb->s_flags |= SB_RDONLY;
903	}
904	break;
905
906	case UFS_MOUNT_UFSTYPE_HP:
907	UFSD("ufstype=hp\n");
908	uspi->s_fsize = block_size = 1024;
909	uspi->s_fmask = ~(1024 - 1);
910	uspi->s_fshift = 10;
911	uspi->s_sbsize = super_block_size = 2048;
912	uspi->s_sbbase = 0;
913	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
914	if (!sb_rdonly(sb)) {
915	if (!silent)
916	pr_info("ufstype=hp is supported read-only\n");
917	sb->s_flags |= SB_RDONLY;
918	}
919	break;
920	default:
921	if (!silent)
922	pr_err("unknown ufstype\n");
923	goto failed;
924	}
925
926	again:
927	if (!sb_set_blocksize(sb, block_size)) {
928	pr_err("failed to set blocksize\n");
929	goto failed;
930	}
931
932	/*
933	* read ufs super block from device
934	*/
935
936	ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
937
938	if (!ubh)
939	goto failed;
940
941	usb1 = ubh_get_usb_first(uspi);
942	usb2 = ubh_get_usb_second(uspi);
943	usb3 = ubh_get_usb_third(uspi);
944
945	/* Sort out mod used on SunOS 4.1.3 for fs_state */
946	uspi->s_postblformat = fs32_to_cpu(sbp: sb, n: usb3->fs_postblformat);
947	if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
948	(uspi->s_postblformat != UFS_42POSTBLFMT)) {
949	flags &= ~UFS_ST_MASK;
950	flags |= UFS_ST_SUN;
951	}
952
953	if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
954	uspi->s_postblformat == UFS_42POSTBLFMT) {
955	if (!silent)
956	pr_err("this is not a 44bsd filesystem");
957	goto failed;
958	}
959
960	/*
961	* Check ufs magic number
962	*/
963	sbi->s_bytesex = BYTESEX_LE;
964	switch ((uspi->fs_magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic))) {
965	case UFS_MAGIC:
966	case UFS_MAGIC_BW:
967	case UFS2_MAGIC:
968	case UFS_MAGIC_LFN:
969	case UFS_MAGIC_FEA:
970	case UFS_MAGIC_4GB:
971	goto magic_found;
972	}
973	sbi->s_bytesex = BYTESEX_BE;
974	switch ((uspi->fs_magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic))) {
975	case UFS_MAGIC:
976	case UFS_MAGIC_BW:
977	case UFS2_MAGIC:
978	case UFS_MAGIC_LFN:
979	case UFS_MAGIC_FEA:
980	case UFS_MAGIC_4GB:
981	goto magic_found;
982	}
983
984	if ((sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP
985	|| sbi->s_flavour == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD
986	|| sbi->s_flavour == UFS_MOUNT_UFSTYPE_OPENSTEP)
987	&& uspi->s_sbbase < 256) {
988	ubh_brelse_uspi(uspi);
989	ubh = NULL;
990	uspi->s_sbbase += 8;
991	goto again;
992	}
993	if (!silent)
994	pr_err("%s(): bad magic number\n", __func__);
995	goto failed;
996
997	magic_found:
998	/*
999	* Check block and fragment sizes
1000	*/
1001	uspi->s_bsize = fs32_to_cpu(sbp: sb, n: usb1->fs_bsize);
1002	uspi->s_fsize = fs32_to_cpu(sbp: sb, n: usb1->fs_fsize);
1003	uspi->s_sbsize = fs32_to_cpu(sbp: sb, n: usb1->fs_sbsize);
1004	uspi->s_fmask = fs32_to_cpu(sbp: sb, n: usb1->fs_fmask);
1005	uspi->s_fshift = fs32_to_cpu(sbp: sb, n: usb1->fs_fshift);
1006
1007	if (!is_power_of_2(n: uspi->s_fsize)) {
1008	pr_err("%s(): fragment size %u is not a power of 2\n",
1009	__func__, uspi->s_fsize);
1010	goto failed;
1011	}
1012	if (uspi->s_fsize < 512) {
1013	pr_err("%s(): fragment size %u is too small\n",
1014	__func__, uspi->s_fsize);
1015	goto failed;
1016	}
1017	if (uspi->s_fsize > 4096) {
1018	pr_err("%s(): fragment size %u is too large\n",
1019	__func__, uspi->s_fsize);
1020	goto failed;
1021	}
1022	if (!is_power_of_2(n: uspi->s_bsize)) {
1023	pr_err("%s(): block size %u is not a power of 2\n",
1024	__func__, uspi->s_bsize);
1025	goto failed;
1026	}
1027	if (uspi->s_bsize < 4096) {
1028	pr_err("%s(): block size %u is too small\n",
1029	__func__, uspi->s_bsize);
1030	goto failed;
1031	}
1032	if (uspi->s_bsize / uspi->s_fsize > 8) {
1033	pr_err("%s(): too many fragments per block (%u)\n",
1034	__func__, uspi->s_bsize / uspi->s_fsize);
1035	goto failed;
1036	}
1037	if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
1038	ubh_brelse_uspi(uspi);
1039	ubh = NULL;
1040	block_size = uspi->s_fsize;
1041	super_block_size = uspi->s_sbsize;
1042	UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
1043	goto again;
1044	}
1045
1046	sbi->s_flags = flags;/*after that line some functions use s_flags*/
1047	ufs_print_super_stuff(sb, usb1, usb2, usb3);
1048
1049	/*
1050	* Check, if file system was correctly unmounted.
1051	* If not, make it read only.
1052	*/
1053	if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
1054	((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
1055	(((flags & UFS_ST_MASK) == UFS_ST_SUN ||
1056	(flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
1057	(flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
1058	(ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sbp: sb, n: usb1->fs_time))))) {
1059	switch(usb1->fs_clean) {
1060	case UFS_FSCLEAN:
1061	UFSD("fs is clean\n");
1062	break;
1063	case UFS_FSSTABLE:
1064	UFSD("fs is stable\n");
1065	break;
1066	case UFS_FSLOG:
1067	UFSD("fs is logging fs\n");
1068	break;
1069	case UFS_FSOSF1:
1070	UFSD("fs is DEC OSF/1\n");
1071	break;
1072	case UFS_FSACTIVE:
1073	pr_err("%s(): fs is active\n", __func__);
1074	sb->s_flags |= SB_RDONLY;
1075	break;
1076	case UFS_FSBAD:
1077	pr_err("%s(): fs is bad\n", __func__);
1078	sb->s_flags |= SB_RDONLY;
1079	break;
1080	default:
1081	pr_err("%s(): can't grok fs_clean 0x%x\n",
1082	__func__, usb1->fs_clean);
1083	sb->s_flags |= SB_RDONLY;
1084	break;
1085	}
1086	} else {
1087	pr_err("%s(): fs needs fsck\n", __func__);
1088	sb->s_flags |= SB_RDONLY;
1089	}
1090
1091	/*
1092	* Read ufs_super_block into internal data structures
1093	*/
1094	sb->s_op = &ufs_super_ops;
1095	sb->s_export_op = &ufs_export_ops;
1096
1097	sb->s_magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic);
1098
1099	uspi->s_sblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_sblkno);
1100	uspi->s_cblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_cblkno);
1101	uspi->s_iblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_iblkno);
1102	uspi->s_dblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_dblkno);
1103	uspi->s_cgoffset = fs32_to_cpu(sbp: sb, n: usb1->fs_cgoffset);
1104	uspi->s_cgmask = fs32_to_cpu(sbp: sb, n: usb1->fs_cgmask);
1105
1106	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1107	uspi->s_size = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.fs_size);
1108	uspi->s_dsize = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.fs_dsize);
1109	} else {
1110	uspi->s_size = fs32_to_cpu(sbp: sb, n: usb1->fs_size);
1111	uspi->s_dsize = fs32_to_cpu(sbp: sb, n: usb1->fs_dsize);
1112	}
1113
1114	uspi->s_ncg = fs32_to_cpu(sbp: sb, n: usb1->fs_ncg);
1115	/* s_bsize already set */
1116	/* s_fsize already set */
1117	uspi->s_fpb = fs32_to_cpu(sbp: sb, n: usb1->fs_frag);
1118	uspi->s_minfree = fs32_to_cpu(sbp: sb, n: usb1->fs_minfree);
1119	uspi->s_bmask = fs32_to_cpu(sbp: sb, n: usb1->fs_bmask);
1120	uspi->s_fmask = fs32_to_cpu(sbp: sb, n: usb1->fs_fmask);
1121	uspi->s_bshift = fs32_to_cpu(sbp: sb, n: usb1->fs_bshift);
1122	uspi->s_fshift = fs32_to_cpu(sbp: sb, n: usb1->fs_fshift);
1123	UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
1124	uspi->s_fshift);
1125	uspi->s_fpbshift = fs32_to_cpu(sbp: sb, n: usb1->fs_fragshift);
1126	uspi->s_fsbtodb = fs32_to_cpu(sbp: sb, n: usb1->fs_fsbtodb);
1127	/* s_sbsize already set */
1128	uspi->s_csmask = fs32_to_cpu(sbp: sb, n: usb1->fs_csmask);
1129	uspi->s_csshift = fs32_to_cpu(sbp: sb, n: usb1->fs_csshift);
1130	uspi->s_nindir = fs32_to_cpu(sbp: sb, n: usb1->fs_nindir);
1131	uspi->s_inopb = fs32_to_cpu(sbp: sb, n: usb1->fs_inopb);
1132	uspi->s_nspf = fs32_to_cpu(sbp: sb, n: usb1->fs_nspf);
1133	uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
1134	uspi->s_interleave = fs32_to_cpu(sbp: sb, n: usb1->fs_interleave);
1135	uspi->s_trackskew = fs32_to_cpu(sbp: sb, n: usb1->fs_trackskew);
1136
1137	if (uspi->fs_magic == UFS2_MAGIC)
1138	uspi->s_csaddr = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.fs_csaddr);
1139	else
1140	uspi->s_csaddr = fs32_to_cpu(sbp: sb, n: usb1->fs_csaddr);
1141
1142	uspi->s_cssize = fs32_to_cpu(sbp: sb, n: usb1->fs_cssize);
1143	uspi->s_cgsize = fs32_to_cpu(sbp: sb, n: usb1->fs_cgsize);
1144	uspi->s_ntrak = fs32_to_cpu(sbp: sb, n: usb1->fs_ntrak);
1145	uspi->s_nsect = fs32_to_cpu(sbp: sb, n: usb1->fs_nsect);
1146	uspi->s_spc = fs32_to_cpu(sbp: sb, n: usb1->fs_spc);
1147	uspi->s_ipg = fs32_to_cpu(sbp: sb, n: usb1->fs_ipg);
1148	uspi->s_fpg = fs32_to_cpu(sbp: sb, n: usb1->fs_fpg);
1149	uspi->s_cpc = fs32_to_cpu(sbp: sb, n: usb2->fs_un.fs_u1.fs_cpc);
1150	uspi->s_contigsumsize = fs32_to_cpu(sbp: sb, n: usb3->fs_un2.fs_44.fs_contigsumsize);
1151	uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
1152	uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
1153	uspi->s_nrpos = fs32_to_cpu(sbp: sb, n: usb3->fs_nrpos);
1154	uspi->s_postbloff = fs32_to_cpu(sbp: sb, n: usb3->fs_postbloff);
1155	uspi->s_rotbloff = fs32_to_cpu(sbp: sb, n: usb3->fs_rotbloff);
1156
1157	uspi->s_root_blocks = mul_u64_u32_div(a: uspi->s_dsize,
1158	mul: uspi->s_minfree, div: 100);
1159	if (uspi->s_minfree <= 5) {
1160	uspi->s_time_to_space = ~0ULL;
1161	uspi->s_space_to_time = 0;
1162	usb1->fs_optim = cpu_to_fs32(sbp: sb, UFS_OPTSPACE);
1163	} else {
1164	uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
1165	uspi->s_space_to_time = mul_u64_u32_div(a: uspi->s_dsize,
1166	mul: uspi->s_minfree - 2, div: 100) - 1;
1167	}
1168
1169	/*
1170	* Compute another frequently used values
1171	*/
1172	uspi->s_fpbmask = uspi->s_fpb - 1;
1173	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1174	uspi->s_apbshift = uspi->s_bshift - 3;
1175	else
1176	uspi->s_apbshift = uspi->s_bshift - 2;
1177
1178	uspi->s_apb = 1 << uspi->s_apbshift;
1179	uspi->s_apbmask = uspi->s_apb - 1;
1180	uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
1181	uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
1182	uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
1183	uspi->s_bpf = uspi->s_fsize << 3;
1184	uspi->s_bpfshift = uspi->s_fshift + 3;
1185	uspi->s_bpfmask = uspi->s_bpf - 1;
1186	if (sbi->s_flavour == UFS_MOUNT_UFSTYPE_44BSD ||
1187	sbi->s_flavour == UFS_MOUNT_UFSTYPE_UFS2)
1188	uspi->s_maxsymlinklen =
1189	fs32_to_cpu(sbp: sb, n: usb3->fs_un2.fs_44.fs_maxsymlinklen);
1190
1191	if (uspi->fs_magic == UFS2_MAGIC)
1192	maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
1193	else
1194	maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
1195	if (uspi->s_maxsymlinklen > maxsymlen) {
1196	ufs_warning(sb, function: __func__, fmt: "ufs_read_super: excessive maximum "
1197	"fast symlink size (%u)\n", uspi->s_maxsymlinklen);
1198	uspi->s_maxsymlinklen = maxsymlen;
1199	}
1200	sb->s_maxbytes = ufs_max_bytes(sb);
1201	sb->s_max_links = UFS_LINK_MAX;
1202
1203	inode = ufs_iget(sb, UFS_ROOTINO);
1204	if (IS_ERR(ptr: inode)) {
1205	ret = PTR_ERR(ptr: inode);
1206	goto failed;
1207	}
1208	sb->s_root = d_make_root(inode);
1209	if (!sb->s_root) {
1210	ret = -ENOMEM;
1211	goto failed;
1212	}
1213
1214	ufs_setup_cstotal(sb);
1215	/*
1216	* Read cylinder group structures
1217	*/
1218	if (!sb_rdonly(sb))
1219	if (!ufs_read_cylinder_structures(sb))
1220	goto failed;
1221
1222	UFSD("EXIT\n");
1223	return 0;
1224
1225	failed:
1226	if (ubh)
1227	ubh_brelse_uspi (uspi);
1228	kfree (objp: uspi);
1229	kfree(objp: sbi);
1230	sb->s_fs_info = NULL;
1231	UFSD("EXIT (FAILED)\n");
1232	return ret;
1233
1234	failed_nomem:
1235	UFSD("EXIT (NOMEM)\n");
1236	return -ENOMEM;
1237	}
1238
1239	static int ufs_reconfigure(struct fs_context *fc)
1240	{
1241	struct ufs_sb_private_info * uspi;
1242	struct ufs_super_block_first * usb1;
1243	struct ufs_super_block_third * usb3;
1244	struct ufs_fs_context *ctx = fc->fs_private;
1245	struct super_block *sb = fc->root->d_sb;
1246	unsigned int ufstype;
1247	unsigned int flags;
1248
1249	sync_filesystem(sb);
1250	mutex_lock(&UFS_SB(sb)->s_lock);
1251	uspi = UFS_SB(sb)->s_uspi;
1252	flags = UFS_SB(sb)->s_flags;
1253	usb1 = ubh_get_usb_first(uspi);
1254	usb3 = ubh_get_usb_third(uspi);
1255
1256	ufstype = UFS_SB(sb)->s_flavour;
1257
1258	if ((bool)(fc->sb_flags & SB_RDONLY) == sb_rdonly(sb)) {
1259	UFS_SB(sb)->s_on_err = ctx->on_err;
1260	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1261	return 0;
1262	}
1263
1264	/*
1265	* fs was mouted as rw, remounting ro
1266	*/
1267	if (fc->sb_flags & SB_RDONLY) {
1268	ufs_put_super_internal(sb);
1269	usb1->fs_time = ufs_get_seconds(sbp: sb);
1270	if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1271	|| (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1272	|| (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1273	ufs_set_fs_state(sb, usb1, usb3,
1274	UFS_FSOK - fs32_to_cpu(sbp: sb, n: usb1->fs_time));
1275	ubh_mark_buffer_dirty (USPI_UBH(spi: uspi));
1276	sb->s_flags |= SB_RDONLY;
1277	} else {
1278	/*
1279	* fs was mounted as ro, remounting rw
1280	*/
1281	#ifndef CONFIG_UFS_FS_WRITE
1282	pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1283	mutex_unlock(&UFS_SB(sb)->s_lock);
1284	return -EINVAL;
1285	#else
1286	if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1287	ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
1288	ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1289	ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1290	ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1291	pr_err("this ufstype is read-only supported\n");
1292	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1293	return -EINVAL;
1294	}
1295	if (!ufs_read_cylinder_structures(sb)) {
1296	pr_err("failed during remounting\n");
1297	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1298	return -EPERM;
1299	}
1300	sb->s_flags &= ~SB_RDONLY;
1301	#endif
1302	}
1303	UFS_SB(sb)->s_on_err = ctx->on_err;
1304	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1305	return 0;
1306	}
1307
1308	static int ufs_show_options(struct seq_file *seq, struct dentry *root)
1309	{
1310	struct ufs_sb_info *sbi = UFS_SB(sb: root->d_sb);
1311	unsigned mval = sbi->s_flavour;
1312	const struct constant_table *tp;
1313
1314	tp = ufs_param_ufstype;
1315	while (tp->value && tp->value != mval)
1316	++tp;
1317	seq_printf(m: seq, fmt: ",ufstype=%s", tp->name);
1318
1319	tp = ufs_param_onerror;
1320	mval = sbi->s_on_err;
1321	while (tp->value && tp->value != mval)
1322	++tp;
1323	seq_printf(m: seq, fmt: ",onerror=%s", tp->name);
1324
1325	return 0;
1326	}
1327
1328	static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
1329	{
1330	struct super_block *sb = dentry->d_sb;
1331	struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1332	unsigned flags = UFS_SB(sb)->s_flags;
1333	u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev);
1334
1335	mutex_lock(&UFS_SB(sb)->s_lock);
1336
1337	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1338	buf->f_type = UFS2_MAGIC;
1339	else
1340	buf->f_type = UFS_MAGIC;
1341
1342	buf->f_blocks = uspi->s_dsize;
1343	buf->f_bfree = ufs_freefrags(uspi);
1344	buf->f_ffree = uspi->cs_total.cs_nifree;
1345	buf->f_bsize = sb->s_blocksize;
1346	buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1347	? (buf->f_bfree - uspi->s_root_blocks) : 0;
1348	buf->f_files = uspi->s_ncg * uspi->s_ipg;
1349	buf->f_namelen = UFS_MAXNAMLEN;
1350	buf->f_fsid = u64_to_fsid(v: id);
1351
1352	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1353
1354	return 0;
1355	}
1356
1357	static struct kmem_cache * ufs_inode_cachep;
1358
1359	static struct inode *ufs_alloc_inode(struct super_block *sb)
1360	{
1361	struct ufs_inode_info *ei;
1362
1363	ei = alloc_inode_sb(sb, ufs_inode_cachep, GFP_NOFS);
1364	if (!ei)
1365	return NULL;
1366
1367	inode_set_iversion(inode: &ei->vfs_inode, val: 1);
1368	seqlock_init(&ei->meta_lock);
1369	mutex_init(&ei->truncate_mutex);
1370	return &ei->vfs_inode;
1371	}
1372
1373	static void ufs_free_in_core_inode(struct inode *inode)
1374	{
1375	kmem_cache_free(s: ufs_inode_cachep, objp: UFS_I(inode));
1376	}
1377
1378	static void init_once(void *foo)
1379	{
1380	struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
1381
1382	inode_init_once(&ei->vfs_inode);
1383	}
1384
1385	static int __init init_inodecache(void)
1386	{
1387	ufs_inode_cachep = kmem_cache_create_usercopy(name: "ufs_inode_cache",
1388	size: sizeof(struct ufs_inode_info), align: 0,
1389	flags: (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT),
1390	offsetof(struct ufs_inode_info, i_u1.i_symlink),
1391	sizeof_field(struct ufs_inode_info,
1392	i_u1.i_symlink),
1393	ctor: init_once);
1394	if (ufs_inode_cachep == NULL)
1395	return -ENOMEM;
1396	return 0;
1397	}
1398
1399	static void destroy_inodecache(void)
1400	{
1401	/*
1402	* Make sure all delayed rcu free inodes are flushed before we
1403	* destroy cache.
1404	*/
1405	rcu_barrier();
1406	kmem_cache_destroy(s: ufs_inode_cachep);
1407	}
1408
1409	static const struct super_operations ufs_super_ops = {
1410	.alloc_inode = ufs_alloc_inode,
1411	.free_inode = ufs_free_in_core_inode,
1412	.write_inode = ufs_write_inode,
1413	.evict_inode = ufs_evict_inode,
1414	.put_super = ufs_put_super,
1415	.sync_fs = ufs_sync_fs,
1416	.statfs = ufs_statfs,
1417	.show_options = ufs_show_options,
1418	};
1419
1420	static int ufs_get_tree(struct fs_context *fc)
1421	{
1422	return get_tree_bdev(fc, fill_super: ufs_fill_super);
1423	}
1424
1425	static void ufs_free_fc(struct fs_context *fc)
1426	{
1427	kfree(objp: fc->fs_private);
1428	}
1429
1430	static const struct fs_context_operations ufs_context_ops = {
1431	.parse_param = ufs_parse_param,
1432	.get_tree = ufs_get_tree,
1433	.reconfigure = ufs_reconfigure,
1434	.free = ufs_free_fc,
1435	};
1436
1437	static int ufs_init_fs_context(struct fs_context *fc)
1438	{
1439	struct ufs_fs_context *ctx;
1440
1441	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1442	if (!ctx)
1443	return -ENOMEM;
1444
1445	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
1446	struct super_block *sb = fc->root->d_sb;
1447	struct ufs_sb_info *sbi = UFS_SB(sb);
1448
1449	ctx->flavour = sbi->s_flavour;
1450	ctx->on_err = sbi->s_on_err;
1451	} else {
1452	ctx->flavour = 0;
1453	ctx->on_err = UFS_MOUNT_ONERROR_LOCK;
1454	}
1455
1456	fc->fs_private = ctx;
1457	fc->ops = &ufs_context_ops;
1458
1459	return 0;
1460	}
1461
1462	static struct file_system_type ufs_fs_type = {
1463	.owner = THIS_MODULE,
1464	.name = "ufs",
1465	.kill_sb = kill_block_super,
1466	.init_fs_context = ufs_init_fs_context,
1467	.parameters = ufs_param_spec,
1468	.fs_flags = FS_REQUIRES_DEV,
1469	};
1470	MODULE_ALIAS_FS("ufs");
1471
1472	static int __init init_ufs_fs(void)
1473	{
1474	int err = init_inodecache();
1475	if (err)
1476	goto out1;
1477	err = register_filesystem(&ufs_fs_type);
1478	if (err)
1479	goto out;
1480	return 0;
1481	out:
1482	destroy_inodecache();
1483	out1:
1484	return err;
1485	}
1486
1487	static void __exit exit_ufs_fs(void)
1488	{
1489	unregister_filesystem(&ufs_fs_type);
1490	destroy_inodecache();
1491	}
1492
1493	module_init(init_ufs_fs)
1494	module_exit(exit_ufs_fs)
1495	MODULE_DESCRIPTION("UFS Filesystem");
1496	MODULE_LICENSE("GPL");
1497