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/parser.h>
87	#include <linux/buffer_head.h>
88	#include <linux/vfs.h>
89	#include <linux/log2.h>
90	#include <linux/mount.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_mount_opt & UFS_MOUNT_ONERROR) {
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 {
346	Opt_type_old = UFS_MOUNT_UFSTYPE_OLD,
347	Opt_type_sunx86 = UFS_MOUNT_UFSTYPE_SUNx86,
348	Opt_type_sun = UFS_MOUNT_UFSTYPE_SUN,
349	Opt_type_sunos = UFS_MOUNT_UFSTYPE_SUNOS,
350	Opt_type_44bsd = UFS_MOUNT_UFSTYPE_44BSD,
351	Opt_type_ufs2 = UFS_MOUNT_UFSTYPE_UFS2,
352	Opt_type_hp = UFS_MOUNT_UFSTYPE_HP,
353	Opt_type_nextstepcd = UFS_MOUNT_UFSTYPE_NEXTSTEP_CD,
354	Opt_type_nextstep = UFS_MOUNT_UFSTYPE_NEXTSTEP,
355	Opt_type_openstep = UFS_MOUNT_UFSTYPE_OPENSTEP,
356	Opt_onerror_panic = UFS_MOUNT_ONERROR_PANIC,
357	Opt_onerror_lock = UFS_MOUNT_ONERROR_LOCK,
358	Opt_onerror_umount = UFS_MOUNT_ONERROR_UMOUNT,
359	Opt_onerror_repair = UFS_MOUNT_ONERROR_REPAIR,
360	Opt_err
361	};
362
363	static const match_table_t tokens = {
364	{Opt_type_old, "ufstype=old"},
365	{Opt_type_sunx86, "ufstype=sunx86"},
366	{Opt_type_sun, "ufstype=sun"},
367	{Opt_type_sunos, "ufstype=sunos"},
368	{Opt_type_44bsd, "ufstype=44bsd"},
369	{Opt_type_ufs2, "ufstype=ufs2"},
370	{Opt_type_ufs2, "ufstype=5xbsd"},
371	{Opt_type_hp, "ufstype=hp"},
372	{Opt_type_nextstepcd, "ufstype=nextstep-cd"},
373	{Opt_type_nextstep, "ufstype=nextstep"},
374	{Opt_type_openstep, "ufstype=openstep"},
375	/*end of possible ufs types */
376	{Opt_onerror_panic, "onerror=panic"},
377	{Opt_onerror_lock, "onerror=lock"},
378	{Opt_onerror_umount, "onerror=umount"},
379	{Opt_onerror_repair, "onerror=repair"},
380	{Opt_err, NULL}
381	};
382
383	static int ufs_parse_options (char * options, unsigned * mount_options)
384	{
385	char * p;
386
387	UFSD("ENTER\n");
388
389	if (!options)
390	return 1;
391
392	while ((p = strsep(&options, ",")) != NULL) {
393	substring_t args[MAX_OPT_ARGS];
394	int token;
395	if (!*p)
396	continue;
397
398	token = match_token(p, table: tokens, args);
399	switch (token) {
400	case Opt_type_old:
401	ufs_clear_opt (*mount_options, UFSTYPE);
402	ufs_set_opt (*mount_options, UFSTYPE_OLD);
403	break;
404	case Opt_type_sunx86:
405	ufs_clear_opt (*mount_options, UFSTYPE);
406	ufs_set_opt (*mount_options, UFSTYPE_SUNx86);
407	break;
408	case Opt_type_sun:
409	ufs_clear_opt (*mount_options, UFSTYPE);
410	ufs_set_opt (*mount_options, UFSTYPE_SUN);
411	break;
412	case Opt_type_sunos:
413	ufs_clear_opt(*mount_options, UFSTYPE);
414	ufs_set_opt(*mount_options, UFSTYPE_SUNOS);
415	break;
416	case Opt_type_44bsd:
417	ufs_clear_opt (*mount_options, UFSTYPE);
418	ufs_set_opt (*mount_options, UFSTYPE_44BSD);
419	break;
420	case Opt_type_ufs2:
421	ufs_clear_opt(*mount_options, UFSTYPE);
422	ufs_set_opt(*mount_options, UFSTYPE_UFS2);
423	break;
424	case Opt_type_hp:
425	ufs_clear_opt (*mount_options, UFSTYPE);
426	ufs_set_opt (*mount_options, UFSTYPE_HP);
427	break;
428	case Opt_type_nextstepcd:
429	ufs_clear_opt (*mount_options, UFSTYPE);
430	ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP_CD);
431	break;
432	case Opt_type_nextstep:
433	ufs_clear_opt (*mount_options, UFSTYPE);
434	ufs_set_opt (*mount_options, UFSTYPE_NEXTSTEP);
435	break;
436	case Opt_type_openstep:
437	ufs_clear_opt (*mount_options, UFSTYPE);
438	ufs_set_opt (*mount_options, UFSTYPE_OPENSTEP);
439	break;
440	case Opt_onerror_panic:
441	ufs_clear_opt (*mount_options, ONERROR);
442	ufs_set_opt (*mount_options, ONERROR_PANIC);
443	break;
444	case Opt_onerror_lock:
445	ufs_clear_opt (*mount_options, ONERROR);
446	ufs_set_opt (*mount_options, ONERROR_LOCK);
447	break;
448	case Opt_onerror_umount:
449	ufs_clear_opt (*mount_options, ONERROR);
450	ufs_set_opt (*mount_options, ONERROR_UMOUNT);
451	break;
452	case Opt_onerror_repair:
453	pr_err("Unable to do repair on error, will lock lock instead\n");
454	ufs_clear_opt (*mount_options, ONERROR);
455	ufs_set_opt (*mount_options, ONERROR_REPAIR);
456	break;
457	default:
458	pr_err("Invalid option: \"%s\" or missing value\n", p);
459	return 0;
460	}
461	}
462	return 1;
463	}
464
465	/*
466	* Different types of UFS hold fs_cstotal in different
467	* places, and use different data structure for it.
468	* To make things simpler we just copy fs_cstotal to ufs_sb_private_info
469	*/
470	static void ufs_setup_cstotal(struct super_block *sb)
471	{
472	struct ufs_sb_info *sbi = UFS_SB(sb);
473	struct ufs_sb_private_info *uspi = sbi->s_uspi;
474	struct ufs_super_block_first *usb1;
475	struct ufs_super_block_second *usb2;
476	struct ufs_super_block_third *usb3;
477	unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
478
479	UFSD("ENTER, mtype=%u\n", mtype);
480	usb1 = ubh_get_usb_first(uspi);
481	usb2 = ubh_get_usb_second(uspi);
482	usb3 = ubh_get_usb_third(uspi);
483
484	if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
485	(usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) ||
486	mtype == UFS_MOUNT_UFSTYPE_UFS2) {
487	/*we have statistic in different place, then usual*/
488	uspi->cs_total.cs_ndir = fs64_to_cpu(sbp: sb, n: usb2->fs_un.fs_u2.cs_ndir);
489	uspi->cs_total.cs_nbfree = fs64_to_cpu(sbp: sb, n: usb2->fs_un.fs_u2.cs_nbfree);
490	uspi->cs_total.cs_nifree = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.cs_nifree);
491	uspi->cs_total.cs_nffree = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.cs_nffree);
492	} else {
493	uspi->cs_total.cs_ndir = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_ndir);
494	uspi->cs_total.cs_nbfree = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_nbfree);
495	uspi->cs_total.cs_nifree = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_nifree);
496	uspi->cs_total.cs_nffree = fs32_to_cpu(sbp: sb, n: usb1->fs_cstotal.cs_nffree);
497	}
498	UFSD("EXIT\n");
499	}
500
501	/*
502	* Read on-disk structures associated with cylinder groups
503	*/
504	static int ufs_read_cylinder_structures(struct super_block *sb)
505	{
506	struct ufs_sb_info *sbi = UFS_SB(sb);
507	struct ufs_sb_private_info *uspi = sbi->s_uspi;
508	struct ufs_buffer_head * ubh;
509	unsigned char * base, * space;
510	unsigned size, blks, i;
511
512	UFSD("ENTER\n");
513
514	/*
515	* Read cs structures from (usually) first data block
516	* on the device.
517	*/
518	size = uspi->s_cssize;
519	blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
520	base = space = kmalloc(size, GFP_NOFS);
521	if (!base)
522	goto failed;
523	sbi->s_csp = (struct ufs_csum *)space;
524	for (i = 0; i < blks; i += uspi->s_fpb) {
525	size = uspi->s_bsize;
526	if (i + uspi->s_fpb > blks)
527	size = (blks - i) * uspi->s_fsize;
528
529	ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
530
531	if (!ubh)
532	goto failed;
533
534	ubh_ubhcpymem (space, ubh, size);
535
536	space += size;
537	ubh_brelse (ubh);
538	ubh = NULL;
539	}
540
541	/*
542	* Read cylinder group (we read only first fragment from block
543	* at this time) and prepare internal data structures for cg caching.
544	*/
545	sbi->s_ucg = kmalloc_array(n: uspi->s_ncg, size: sizeof(struct buffer_head *),
546	GFP_NOFS);
547	if (!sbi->s_ucg)
548	goto failed;
549	for (i = 0; i < uspi->s_ncg; i++)
550	sbi->s_ucg[i] = NULL;
551	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
552	sbi->s_ucpi[i] = NULL;
553	sbi->s_cgno[i] = UFS_CGNO_EMPTY;
554	}
555	for (i = 0; i < uspi->s_ncg; i++) {
556	UFSD("read cg %u\n", i);
557	if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
558	goto failed;
559	if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
560	goto failed;
561
562	ufs_print_cylinder_stuff(sb, cg: (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
563	}
564	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
565	if (!(sbi->s_ucpi[i] = kmalloc (size: sizeof(struct ufs_cg_private_info), GFP_NOFS)))
566	goto failed;
567	sbi->s_cgno[i] = UFS_CGNO_EMPTY;
568	}
569	sbi->s_cg_loaded = 0;
570	UFSD("EXIT\n");
571	return 1;
572
573	failed:
574	kfree (objp: base);
575	if (sbi->s_ucg) {
576	for (i = 0; i < uspi->s_ncg; i++)
577	if (sbi->s_ucg[i])
578	brelse (bh: sbi->s_ucg[i]);
579	kfree (objp: sbi->s_ucg);
580	for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
581	kfree (objp: sbi->s_ucpi[i]);
582	}
583	UFSD("EXIT (FAILED)\n");
584	return 0;
585	}
586
587	/*
588	* Sync our internal copy of fs_cstotal with disk
589	*/
590	static void ufs_put_cstotal(struct super_block *sb)
591	{
592	unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
593	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
594	struct ufs_super_block_first *usb1;
595	struct ufs_super_block_second *usb2;
596	struct ufs_super_block_third *usb3;
597
598	UFSD("ENTER\n");
599	usb1 = ubh_get_usb_first(uspi);
600	usb2 = ubh_get_usb_second(uspi);
601	usb3 = ubh_get_usb_third(uspi);
602
603	if (mtype == UFS_MOUNT_UFSTYPE_UFS2) {
604	/*we have statistic in different place, then usual*/
605	usb2->fs_un.fs_u2.cs_ndir =
606	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_ndir);
607	usb2->fs_un.fs_u2.cs_nbfree =
608	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nbfree);
609	usb3->fs_un1.fs_u2.cs_nifree =
610	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nifree);
611	usb3->fs_un1.fs_u2.cs_nffree =
612	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nffree);
613	goto out;
614	}
615
616	if (mtype == UFS_MOUNT_UFSTYPE_44BSD &&
617	(usb2->fs_un.fs_u2.fs_maxbsize == usb1->fs_bsize)) {
618	/* store stats in both old and new places */
619	usb2->fs_un.fs_u2.cs_ndir =
620	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_ndir);
621	usb2->fs_un.fs_u2.cs_nbfree =
622	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nbfree);
623	usb3->fs_un1.fs_u2.cs_nifree =
624	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nifree);
625	usb3->fs_un1.fs_u2.cs_nffree =
626	cpu_to_fs64(sbp: sb, n: uspi->cs_total.cs_nffree);
627	}
628	usb1->fs_cstotal.cs_ndir = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_ndir);
629	usb1->fs_cstotal.cs_nbfree = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_nbfree);
630	usb1->fs_cstotal.cs_nifree = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_nifree);
631	usb1->fs_cstotal.cs_nffree = cpu_to_fs32(sbp: sb, n: uspi->cs_total.cs_nffree);
632	out:
633	ubh_mark_buffer_dirty(USPI_UBH(spi: uspi));
634	ufs_print_super_stuff(sb, usb1, usb2, usb3);
635	UFSD("EXIT\n");
636	}
637
638	/**
639	* ufs_put_super_internal() - put on-disk intrenal structures
640	* @sb: pointer to super_block structure
641	* Put on-disk structures associated with cylinder groups
642	* and write them back to disk, also update cs_total on disk
643	*/
644	static void ufs_put_super_internal(struct super_block *sb)
645	{
646	struct ufs_sb_info *sbi = UFS_SB(sb);
647	struct ufs_sb_private_info *uspi = sbi->s_uspi;
648	struct ufs_buffer_head * ubh;
649	unsigned char * base, * space;
650	unsigned blks, size, i;
651
652
653	UFSD("ENTER\n");
654
655	ufs_put_cstotal(sb);
656	size = uspi->s_cssize;
657	blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
658	base = space = (char*) sbi->s_csp;
659	for (i = 0; i < blks; i += uspi->s_fpb) {
660	size = uspi->s_bsize;
661	if (i + uspi->s_fpb > blks)
662	size = (blks - i) * uspi->s_fsize;
663
664	ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
665
666	ubh_memcpyubh (ubh, space, size);
667	space += size;
668	ubh_mark_buffer_uptodate (ubh, 1);
669	ubh_mark_buffer_dirty (ubh);
670	ubh_brelse (ubh);
671	}
672	for (i = 0; i < sbi->s_cg_loaded; i++) {
673	ufs_put_cylinder (sb, i);
674	kfree (objp: sbi->s_ucpi[i]);
675	}
676	for (; i < UFS_MAX_GROUP_LOADED; i++)
677	kfree (objp: sbi->s_ucpi[i]);
678	for (i = 0; i < uspi->s_ncg; i++)
679	brelse (bh: sbi->s_ucg[i]);
680	kfree (objp: sbi->s_ucg);
681	kfree (objp: base);
682
683	UFSD("EXIT\n");
684	}
685
686	static int ufs_sync_fs(struct super_block *sb, int wait)
687	{
688	struct ufs_sb_private_info * uspi;
689	struct ufs_super_block_first * usb1;
690	struct ufs_super_block_third * usb3;
691	unsigned flags;
692
693	mutex_lock(&UFS_SB(sb)->s_lock);
694
695	UFSD("ENTER\n");
696
697	flags = UFS_SB(sb)->s_flags;
698	uspi = UFS_SB(sb)->s_uspi;
699	usb1 = ubh_get_usb_first(uspi);
700	usb3 = ubh_get_usb_third(uspi);
701
702	usb1->fs_time = ufs_get_seconds(sbp: sb);
703	if ((flags & UFS_ST_MASK) == UFS_ST_SUN ||
704	(flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
705	(flags & UFS_ST_MASK) == UFS_ST_SUNx86)
706	ufs_set_fs_state(sb, usb1, usb3,
707	UFS_FSOK - fs32_to_cpu(sbp: sb, n: usb1->fs_time));
708	ufs_put_cstotal(sb);
709
710	UFSD("EXIT\n");
711	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
712
713	return 0;
714	}
715
716	static void delayed_sync_fs(struct work_struct *work)
717	{
718	struct ufs_sb_info *sbi;
719
720	sbi = container_of(work, struct ufs_sb_info, sync_work.work);
721
722	spin_lock(lock: &sbi->work_lock);
723	sbi->work_queued = 0;
724	spin_unlock(lock: &sbi->work_lock);
725
726	ufs_sync_fs(sb: sbi->sb, wait: 1);
727	}
728
729	void ufs_mark_sb_dirty(struct super_block *sb)
730	{
731	struct ufs_sb_info *sbi = UFS_SB(sb);
732	unsigned long delay;
733
734	spin_lock(lock: &sbi->work_lock);
735	if (!sbi->work_queued) {
736	delay = msecs_to_jiffies(m: dirty_writeback_interval * 10);
737	queue_delayed_work(wq: system_long_wq, dwork: &sbi->sync_work, delay);
738	sbi->work_queued = 1;
739	}
740	spin_unlock(lock: &sbi->work_lock);
741	}
742
743	static void ufs_put_super(struct super_block *sb)
744	{
745	struct ufs_sb_info * sbi = UFS_SB(sb);
746
747	UFSD("ENTER\n");
748
749	if (!sb_rdonly(sb))
750	ufs_put_super_internal(sb);
751	cancel_delayed_work_sync(dwork: &sbi->sync_work);
752
753	ubh_brelse_uspi (sbi->s_uspi);
754	kfree (objp: sbi->s_uspi);
755	kfree (objp: sbi);
756	sb->s_fs_info = NULL;
757	UFSD("EXIT\n");
758	return;
759	}
760
761	static u64 ufs_max_bytes(struct super_block *sb)
762	{
763	struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
764	int bits = uspi->s_apbshift;
765	u64 res;
766
767	if (bits > 21)
768	res = ~0ULL;
769	else
770	res = UFS_NDADDR + (1LL << bits) + (1LL << (2*bits)) +
771	(1LL << (3*bits));
772
773	if (res >= (MAX_LFS_FILESIZE >> uspi->s_bshift))
774	return MAX_LFS_FILESIZE;
775	return res << uspi->s_bshift;
776	}
777
778	static int ufs_fill_super(struct super_block *sb, void *data, int silent)
779	{
780	struct ufs_sb_info * sbi;
781	struct ufs_sb_private_info * uspi;
782	struct ufs_super_block_first * usb1;
783	struct ufs_super_block_second * usb2;
784	struct ufs_super_block_third * usb3;
785	struct ufs_buffer_head * ubh;
786	struct inode *inode;
787	unsigned block_size, super_block_size;
788	unsigned flags;
789	unsigned super_block_offset;
790	unsigned maxsymlen;
791	int ret = -EINVAL;
792
793	uspi = NULL;
794	ubh = NULL;
795	flags = 0;
796
797	UFSD("ENTER\n");
798
799	#ifndef CONFIG_UFS_FS_WRITE
800	if (!sb_rdonly(sb)) {
801	pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
802	return -EROFS;
803	}
804	#endif
805
806	sbi = kzalloc(size: sizeof(struct ufs_sb_info), GFP_KERNEL);
807	if (!sbi)
808	goto failed_nomem;
809	sb->s_fs_info = sbi;
810	sbi->sb = sb;
811
812	UFSD("flag %u\n", (int)(sb_rdonly(sb)));
813
814	mutex_init(&sbi->s_lock);
815	spin_lock_init(&sbi->work_lock);
816	INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
817	/*
818	* Set default mount options
819	* Parse mount options
820	*/
821	sbi->s_mount_opt = 0;
822	ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
823	if (!ufs_parse_options (options: (char *) data, mount_options: &sbi->s_mount_opt)) {
824	pr_err("wrong mount options\n");
825	goto failed;
826	}
827	if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
828	if (!silent)
829	pr_err("You didn't specify the type of your ufs filesystem\n\n"
830	"mount -t ufs -o ufstype="
831	"sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
832	">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
833	"default is ufstype=old\n");
834	ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
835	}
836
837	uspi = kzalloc(size: sizeof(struct ufs_sb_private_info), GFP_KERNEL);
838	sbi->s_uspi = uspi;
839	if (!uspi)
840	goto failed;
841	uspi->s_dirblksize = UFS_SECTOR_SIZE;
842	super_block_offset=UFS_SBLOCK;
843
844	sb->s_maxbytes = MAX_LFS_FILESIZE;
845
846	sb->s_time_gran = NSEC_PER_SEC;
847	sb->s_time_min = S32_MIN;
848	sb->s_time_max = S32_MAX;
849
850	switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
851	case UFS_MOUNT_UFSTYPE_44BSD:
852	UFSD("ufstype=44bsd\n");
853	uspi->s_fsize = block_size = 512;
854	uspi->s_fmask = ~(512 - 1);
855	uspi->s_fshift = 9;
856	uspi->s_sbsize = super_block_size = 1536;
857	uspi->s_sbbase = 0;
858	flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
859	break;
860	case UFS_MOUNT_UFSTYPE_UFS2:
861	UFSD("ufstype=ufs2\n");
862	super_block_offset=SBLOCK_UFS2;
863	uspi->s_fsize = block_size = 512;
864	uspi->s_fmask = ~(512 - 1);
865	uspi->s_fshift = 9;
866	uspi->s_sbsize = super_block_size = 1536;
867	uspi->s_sbbase = 0;
868	sb->s_time_gran = 1;
869	sb->s_time_min = S64_MIN;
870	sb->s_time_max = S64_MAX;
871	flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
872	break;
873
874	case UFS_MOUNT_UFSTYPE_SUN:
875	UFSD("ufstype=sun\n");
876	uspi->s_fsize = block_size = 1024;
877	uspi->s_fmask = ~(1024 - 1);
878	uspi->s_fshift = 10;
879	uspi->s_sbsize = super_block_size = 2048;
880	uspi->s_sbbase = 0;
881	uspi->s_maxsymlinklen = 0; /* Not supported on disk */
882	flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
883	break;
884
885	case UFS_MOUNT_UFSTYPE_SUNOS:
886	UFSD("ufstype=sunos\n");
887	uspi->s_fsize = block_size = 1024;
888	uspi->s_fmask = ~(1024 - 1);
889	uspi->s_fshift = 10;
890	uspi->s_sbsize = 2048;
891	super_block_size = 2048;
892	uspi->s_sbbase = 0;
893	uspi->s_maxsymlinklen = 0; /* Not supported on disk */
894	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
895	break;
896
897	case UFS_MOUNT_UFSTYPE_SUNx86:
898	UFSD("ufstype=sunx86\n");
899	uspi->s_fsize = block_size = 1024;
900	uspi->s_fmask = ~(1024 - 1);
901	uspi->s_fshift = 10;
902	uspi->s_sbsize = super_block_size = 2048;
903	uspi->s_sbbase = 0;
904	uspi->s_maxsymlinklen = 0; /* Not supported on disk */
905	flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
906	break;
907
908	case UFS_MOUNT_UFSTYPE_OLD:
909	UFSD("ufstype=old\n");
910	uspi->s_fsize = block_size = 1024;
911	uspi->s_fmask = ~(1024 - 1);
912	uspi->s_fshift = 10;
913	uspi->s_sbsize = super_block_size = 2048;
914	uspi->s_sbbase = 0;
915	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
916	if (!sb_rdonly(sb)) {
917	if (!silent)
918	pr_info("ufstype=old is supported read-only\n");
919	sb->s_flags |= SB_RDONLY;
920	}
921	break;
922
923	case UFS_MOUNT_UFSTYPE_NEXTSTEP:
924	UFSD("ufstype=nextstep\n");
925	uspi->s_fsize = block_size = 1024;
926	uspi->s_fmask = ~(1024 - 1);
927	uspi->s_fshift = 10;
928	uspi->s_sbsize = super_block_size = 2048;
929	uspi->s_sbbase = 0;
930	uspi->s_dirblksize = 1024;
931	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
932	if (!sb_rdonly(sb)) {
933	if (!silent)
934	pr_info("ufstype=nextstep is supported read-only\n");
935	sb->s_flags |= SB_RDONLY;
936	}
937	break;
938
939	case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
940	UFSD("ufstype=nextstep-cd\n");
941	uspi->s_fsize = block_size = 2048;
942	uspi->s_fmask = ~(2048 - 1);
943	uspi->s_fshift = 11;
944	uspi->s_sbsize = super_block_size = 2048;
945	uspi->s_sbbase = 0;
946	uspi->s_dirblksize = 1024;
947	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
948	if (!sb_rdonly(sb)) {
949	if (!silent)
950	pr_info("ufstype=nextstep-cd is supported read-only\n");
951	sb->s_flags |= SB_RDONLY;
952	}
953	break;
954
955	case UFS_MOUNT_UFSTYPE_OPENSTEP:
956	UFSD("ufstype=openstep\n");
957	uspi->s_fsize = block_size = 1024;
958	uspi->s_fmask = ~(1024 - 1);
959	uspi->s_fshift = 10;
960	uspi->s_sbsize = super_block_size = 2048;
961	uspi->s_sbbase = 0;
962	uspi->s_dirblksize = 1024;
963	flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
964	if (!sb_rdonly(sb)) {
965	if (!silent)
966	pr_info("ufstype=openstep is supported read-only\n");
967	sb->s_flags |= SB_RDONLY;
968	}
969	break;
970
971	case UFS_MOUNT_UFSTYPE_HP:
972	UFSD("ufstype=hp\n");
973	uspi->s_fsize = block_size = 1024;
974	uspi->s_fmask = ~(1024 - 1);
975	uspi->s_fshift = 10;
976	uspi->s_sbsize = super_block_size = 2048;
977	uspi->s_sbbase = 0;
978	flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
979	if (!sb_rdonly(sb)) {
980	if (!silent)
981	pr_info("ufstype=hp is supported read-only\n");
982	sb->s_flags |= SB_RDONLY;
983	}
984	break;
985	default:
986	if (!silent)
987	pr_err("unknown ufstype\n");
988	goto failed;
989	}
990
991	again:
992	if (!sb_set_blocksize(sb, block_size)) {
993	pr_err("failed to set blocksize\n");
994	goto failed;
995	}
996
997	/*
998	* read ufs super block from device
999	*/
1000
1001	ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
1002
1003	if (!ubh)
1004	goto failed;
1005
1006	usb1 = ubh_get_usb_first(uspi);
1007	usb2 = ubh_get_usb_second(uspi);
1008	usb3 = ubh_get_usb_third(uspi);
1009
1010	/* Sort out mod used on SunOS 4.1.3 for fs_state */
1011	uspi->s_postblformat = fs32_to_cpu(sbp: sb, n: usb3->fs_postblformat);
1012	if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
1013	(uspi->s_postblformat != UFS_42POSTBLFMT)) {
1014	flags &= ~UFS_ST_MASK;
1015	flags |= UFS_ST_SUN;
1016	}
1017
1018	if ((flags & UFS_ST_MASK) == UFS_ST_44BSD &&
1019	uspi->s_postblformat == UFS_42POSTBLFMT) {
1020	if (!silent)
1021	pr_err("this is not a 44bsd filesystem");
1022	goto failed;
1023	}
1024
1025	/*
1026	* Check ufs magic number
1027	*/
1028	sbi->s_bytesex = BYTESEX_LE;
1029	switch ((uspi->fs_magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic))) {
1030	case UFS_MAGIC:
1031	case UFS_MAGIC_BW:
1032	case UFS2_MAGIC:
1033	case UFS_MAGIC_LFN:
1034	case UFS_MAGIC_FEA:
1035	case UFS_MAGIC_4GB:
1036	goto magic_found;
1037	}
1038	sbi->s_bytesex = BYTESEX_BE;
1039	switch ((uspi->fs_magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic))) {
1040	case UFS_MAGIC:
1041	case UFS_MAGIC_BW:
1042	case UFS2_MAGIC:
1043	case UFS_MAGIC_LFN:
1044	case UFS_MAGIC_FEA:
1045	case UFS_MAGIC_4GB:
1046	goto magic_found;
1047	}
1048
1049	if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
1050	|| ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
1051	|| ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP))
1052	&& uspi->s_sbbase < 256) {
1053	ubh_brelse_uspi(uspi);
1054	ubh = NULL;
1055	uspi->s_sbbase += 8;
1056	goto again;
1057	}
1058	if (!silent)
1059	pr_err("%s(): bad magic number\n", __func__);
1060	goto failed;
1061
1062	magic_found:
1063	/*
1064	* Check block and fragment sizes
1065	*/
1066	uspi->s_bsize = fs32_to_cpu(sbp: sb, n: usb1->fs_bsize);
1067	uspi->s_fsize = fs32_to_cpu(sbp: sb, n: usb1->fs_fsize);
1068	uspi->s_sbsize = fs32_to_cpu(sbp: sb, n: usb1->fs_sbsize);
1069	uspi->s_fmask = fs32_to_cpu(sbp: sb, n: usb1->fs_fmask);
1070	uspi->s_fshift = fs32_to_cpu(sbp: sb, n: usb1->fs_fshift);
1071
1072	if (!is_power_of_2(n: uspi->s_fsize)) {
1073	pr_err("%s(): fragment size %u is not a power of 2\n",
1074	__func__, uspi->s_fsize);
1075	goto failed;
1076	}
1077	if (uspi->s_fsize < 512) {
1078	pr_err("%s(): fragment size %u is too small\n",
1079	__func__, uspi->s_fsize);
1080	goto failed;
1081	}
1082	if (uspi->s_fsize > 4096) {
1083	pr_err("%s(): fragment size %u is too large\n",
1084	__func__, uspi->s_fsize);
1085	goto failed;
1086	}
1087	if (!is_power_of_2(n: uspi->s_bsize)) {
1088	pr_err("%s(): block size %u is not a power of 2\n",
1089	__func__, uspi->s_bsize);
1090	goto failed;
1091	}
1092	if (uspi->s_bsize < 4096) {
1093	pr_err("%s(): block size %u is too small\n",
1094	__func__, uspi->s_bsize);
1095	goto failed;
1096	}
1097	if (uspi->s_bsize / uspi->s_fsize > 8) {
1098	pr_err("%s(): too many fragments per block (%u)\n",
1099	__func__, uspi->s_bsize / uspi->s_fsize);
1100	goto failed;
1101	}
1102	if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
1103	ubh_brelse_uspi(uspi);
1104	ubh = NULL;
1105	block_size = uspi->s_fsize;
1106	super_block_size = uspi->s_sbsize;
1107	UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
1108	goto again;
1109	}
1110
1111	sbi->s_flags = flags;/*after that line some functions use s_flags*/
1112	ufs_print_super_stuff(sb, usb1, usb2, usb3);
1113
1114	/*
1115	* Check, if file system was correctly unmounted.
1116	* If not, make it read only.
1117	*/
1118	if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
1119	((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
1120	(((flags & UFS_ST_MASK) == UFS_ST_SUN ||
1121	(flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
1122	(flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
1123	(ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sbp: sb, n: usb1->fs_time))))) {
1124	switch(usb1->fs_clean) {
1125	case UFS_FSCLEAN:
1126	UFSD("fs is clean\n");
1127	break;
1128	case UFS_FSSTABLE:
1129	UFSD("fs is stable\n");
1130	break;
1131	case UFS_FSLOG:
1132	UFSD("fs is logging fs\n");
1133	break;
1134	case UFS_FSOSF1:
1135	UFSD("fs is DEC OSF/1\n");
1136	break;
1137	case UFS_FSACTIVE:
1138	pr_err("%s(): fs is active\n", __func__);
1139	sb->s_flags |= SB_RDONLY;
1140	break;
1141	case UFS_FSBAD:
1142	pr_err("%s(): fs is bad\n", __func__);
1143	sb->s_flags |= SB_RDONLY;
1144	break;
1145	default:
1146	pr_err("%s(): can't grok fs_clean 0x%x\n",
1147	__func__, usb1->fs_clean);
1148	sb->s_flags |= SB_RDONLY;
1149	break;
1150	}
1151	} else {
1152	pr_err("%s(): fs needs fsck\n", __func__);
1153	sb->s_flags |= SB_RDONLY;
1154	}
1155
1156	/*
1157	* Read ufs_super_block into internal data structures
1158	*/
1159	sb->s_op = &ufs_super_ops;
1160	sb->s_export_op = &ufs_export_ops;
1161
1162	sb->s_magic = fs32_to_cpu(sbp: sb, n: usb3->fs_magic);
1163
1164	uspi->s_sblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_sblkno);
1165	uspi->s_cblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_cblkno);
1166	uspi->s_iblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_iblkno);
1167	uspi->s_dblkno = fs32_to_cpu(sbp: sb, n: usb1->fs_dblkno);
1168	uspi->s_cgoffset = fs32_to_cpu(sbp: sb, n: usb1->fs_cgoffset);
1169	uspi->s_cgmask = fs32_to_cpu(sbp: sb, n: usb1->fs_cgmask);
1170
1171	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
1172	uspi->s_size = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.fs_size);
1173	uspi->s_dsize = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.fs_dsize);
1174	} else {
1175	uspi->s_size = fs32_to_cpu(sbp: sb, n: usb1->fs_size);
1176	uspi->s_dsize = fs32_to_cpu(sbp: sb, n: usb1->fs_dsize);
1177	}
1178
1179	uspi->s_ncg = fs32_to_cpu(sbp: sb, n: usb1->fs_ncg);
1180	/* s_bsize already set */
1181	/* s_fsize already set */
1182	uspi->s_fpb = fs32_to_cpu(sbp: sb, n: usb1->fs_frag);
1183	uspi->s_minfree = fs32_to_cpu(sbp: sb, n: usb1->fs_minfree);
1184	uspi->s_bmask = fs32_to_cpu(sbp: sb, n: usb1->fs_bmask);
1185	uspi->s_fmask = fs32_to_cpu(sbp: sb, n: usb1->fs_fmask);
1186	uspi->s_bshift = fs32_to_cpu(sbp: sb, n: usb1->fs_bshift);
1187	uspi->s_fshift = fs32_to_cpu(sbp: sb, n: usb1->fs_fshift);
1188	UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
1189	uspi->s_fshift);
1190	uspi->s_fpbshift = fs32_to_cpu(sbp: sb, n: usb1->fs_fragshift);
1191	uspi->s_fsbtodb = fs32_to_cpu(sbp: sb, n: usb1->fs_fsbtodb);
1192	/* s_sbsize already set */
1193	uspi->s_csmask = fs32_to_cpu(sbp: sb, n: usb1->fs_csmask);
1194	uspi->s_csshift = fs32_to_cpu(sbp: sb, n: usb1->fs_csshift);
1195	uspi->s_nindir = fs32_to_cpu(sbp: sb, n: usb1->fs_nindir);
1196	uspi->s_inopb = fs32_to_cpu(sbp: sb, n: usb1->fs_inopb);
1197	uspi->s_nspf = fs32_to_cpu(sbp: sb, n: usb1->fs_nspf);
1198	uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
1199	uspi->s_interleave = fs32_to_cpu(sbp: sb, n: usb1->fs_interleave);
1200	uspi->s_trackskew = fs32_to_cpu(sbp: sb, n: usb1->fs_trackskew);
1201
1202	if (uspi->fs_magic == UFS2_MAGIC)
1203	uspi->s_csaddr = fs64_to_cpu(sbp: sb, n: usb3->fs_un1.fs_u2.fs_csaddr);
1204	else
1205	uspi->s_csaddr = fs32_to_cpu(sbp: sb, n: usb1->fs_csaddr);
1206
1207	uspi->s_cssize = fs32_to_cpu(sbp: sb, n: usb1->fs_cssize);
1208	uspi->s_cgsize = fs32_to_cpu(sbp: sb, n: usb1->fs_cgsize);
1209	uspi->s_ntrak = fs32_to_cpu(sbp: sb, n: usb1->fs_ntrak);
1210	uspi->s_nsect = fs32_to_cpu(sbp: sb, n: usb1->fs_nsect);
1211	uspi->s_spc = fs32_to_cpu(sbp: sb, n: usb1->fs_spc);
1212	uspi->s_ipg = fs32_to_cpu(sbp: sb, n: usb1->fs_ipg);
1213	uspi->s_fpg = fs32_to_cpu(sbp: sb, n: usb1->fs_fpg);
1214	uspi->s_cpc = fs32_to_cpu(sbp: sb, n: usb2->fs_un.fs_u1.fs_cpc);
1215	uspi->s_contigsumsize = fs32_to_cpu(sbp: sb, n: usb3->fs_un2.fs_44.fs_contigsumsize);
1216	uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
1217	uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
1218	uspi->s_nrpos = fs32_to_cpu(sbp: sb, n: usb3->fs_nrpos);
1219	uspi->s_postbloff = fs32_to_cpu(sbp: sb, n: usb3->fs_postbloff);
1220	uspi->s_rotbloff = fs32_to_cpu(sbp: sb, n: usb3->fs_rotbloff);
1221
1222	uspi->s_root_blocks = mul_u64_u32_div(a: uspi->s_dsize,
1223	mul: uspi->s_minfree, div: 100);
1224	if (uspi->s_minfree <= 5) {
1225	uspi->s_time_to_space = ~0ULL;
1226	uspi->s_space_to_time = 0;
1227	usb1->fs_optim = cpu_to_fs32(sbp: sb, UFS_OPTSPACE);
1228	} else {
1229	uspi->s_time_to_space = (uspi->s_root_blocks / 2) + 1;
1230	uspi->s_space_to_time = mul_u64_u32_div(a: uspi->s_dsize,
1231	mul: uspi->s_minfree - 2, div: 100) - 1;
1232	}
1233
1234	/*
1235	* Compute another frequently used values
1236	*/
1237	uspi->s_fpbmask = uspi->s_fpb - 1;
1238	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1239	uspi->s_apbshift = uspi->s_bshift - 3;
1240	else
1241	uspi->s_apbshift = uspi->s_bshift - 2;
1242
1243	uspi->s_2apbshift = uspi->s_apbshift * 2;
1244	uspi->s_3apbshift = uspi->s_apbshift * 3;
1245	uspi->s_apb = 1 << uspi->s_apbshift;
1246	uspi->s_2apb = 1 << uspi->s_2apbshift;
1247	uspi->s_3apb = 1 << uspi->s_3apbshift;
1248	uspi->s_apbmask = uspi->s_apb - 1;
1249	uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
1250	uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
1251	uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
1252	uspi->s_bpf = uspi->s_fsize << 3;
1253	uspi->s_bpfshift = uspi->s_fshift + 3;
1254	uspi->s_bpfmask = uspi->s_bpf - 1;
1255	if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||
1256	(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)
1257	uspi->s_maxsymlinklen =
1258	fs32_to_cpu(sbp: sb, n: usb3->fs_un2.fs_44.fs_maxsymlinklen);
1259
1260	if (uspi->fs_magic == UFS2_MAGIC)
1261	maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
1262	else
1263	maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
1264	if (uspi->s_maxsymlinklen > maxsymlen) {
1265	ufs_warning(sb, function: __func__, fmt: "ufs_read_super: excessive maximum "
1266	"fast symlink size (%u)\n", uspi->s_maxsymlinklen);
1267	uspi->s_maxsymlinklen = maxsymlen;
1268	}
1269	sb->s_maxbytes = ufs_max_bytes(sb);
1270	sb->s_max_links = UFS_LINK_MAX;
1271
1272	inode = ufs_iget(sb, UFS_ROOTINO);
1273	if (IS_ERR(ptr: inode)) {
1274	ret = PTR_ERR(ptr: inode);
1275	goto failed;
1276	}
1277	sb->s_root = d_make_root(inode);
1278	if (!sb->s_root) {
1279	ret = -ENOMEM;
1280	goto failed;
1281	}
1282
1283	ufs_setup_cstotal(sb);
1284	/*
1285	* Read cylinder group structures
1286	*/
1287	if (!sb_rdonly(sb))
1288	if (!ufs_read_cylinder_structures(sb))
1289	goto failed;
1290
1291	UFSD("EXIT\n");
1292	return 0;
1293
1294	failed:
1295	if (ubh)
1296	ubh_brelse_uspi (uspi);
1297	kfree (objp: uspi);
1298	kfree(objp: sbi);
1299	sb->s_fs_info = NULL;
1300	UFSD("EXIT (FAILED)\n");
1301	return ret;
1302
1303	failed_nomem:
1304	UFSD("EXIT (NOMEM)\n");
1305	return -ENOMEM;
1306	}
1307
1308	static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
1309	{
1310	struct ufs_sb_private_info * uspi;
1311	struct ufs_super_block_first * usb1;
1312	struct ufs_super_block_third * usb3;
1313	unsigned new_mount_opt, ufstype;
1314	unsigned flags;
1315
1316	sync_filesystem(sb);
1317	mutex_lock(&UFS_SB(sb)->s_lock);
1318	uspi = UFS_SB(sb)->s_uspi;
1319	flags = UFS_SB(sb)->s_flags;
1320	usb1 = ubh_get_usb_first(uspi);
1321	usb3 = ubh_get_usb_third(uspi);
1322
1323	/*
1324	* Allow the "check" option to be passed as a remount option.
1325	* It is not possible to change ufstype option during remount
1326	*/
1327	ufstype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
1328	new_mount_opt = 0;
1329	ufs_set_opt (new_mount_opt, ONERROR_LOCK);
1330	if (!ufs_parse_options (options: data, mount_options: &new_mount_opt)) {
1331	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1332	return -EINVAL;
1333	}
1334	if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
1335	new_mount_opt |= ufstype;
1336	} else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
1337	pr_err("ufstype can't be changed during remount\n");
1338	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1339	return -EINVAL;
1340	}
1341
1342	if ((bool)(*mount_flags & SB_RDONLY) == sb_rdonly(sb)) {
1343	UFS_SB(sb)->s_mount_opt = new_mount_opt;
1344	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1345	return 0;
1346	}
1347
1348	/*
1349	* fs was mouted as rw, remounting ro
1350	*/
1351	if (*mount_flags & SB_RDONLY) {
1352	ufs_put_super_internal(sb);
1353	usb1->fs_time = ufs_get_seconds(sbp: sb);
1354	if ((flags & UFS_ST_MASK) == UFS_ST_SUN
1355	|| (flags & UFS_ST_MASK) == UFS_ST_SUNOS
1356	|| (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
1357	ufs_set_fs_state(sb, usb1, usb3,
1358	UFS_FSOK - fs32_to_cpu(sbp: sb, n: usb1->fs_time));
1359	ubh_mark_buffer_dirty (USPI_UBH(spi: uspi));
1360	sb->s_flags |= SB_RDONLY;
1361	} else {
1362	/*
1363	* fs was mounted as ro, remounting rw
1364	*/
1365	#ifndef CONFIG_UFS_FS_WRITE
1366	pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
1367	mutex_unlock(&UFS_SB(sb)->s_lock);
1368	return -EINVAL;
1369	#else
1370	if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
1371	ufstype != UFS_MOUNT_UFSTYPE_SUNOS &&
1372	ufstype != UFS_MOUNT_UFSTYPE_44BSD &&
1373	ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
1374	ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
1375	pr_err("this ufstype is read-only supported\n");
1376	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1377	return -EINVAL;
1378	}
1379	if (!ufs_read_cylinder_structures(sb)) {
1380	pr_err("failed during remounting\n");
1381	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1382	return -EPERM;
1383	}
1384	sb->s_flags &= ~SB_RDONLY;
1385	#endif
1386	}
1387	UFS_SB(sb)->s_mount_opt = new_mount_opt;
1388	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1389	return 0;
1390	}
1391
1392	static int ufs_show_options(struct seq_file *seq, struct dentry *root)
1393	{
1394	struct ufs_sb_info *sbi = UFS_SB(sb: root->d_sb);
1395	unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
1396	const struct match_token *tp = tokens;
1397
1398	while (tp->token != Opt_onerror_panic && tp->token != mval)
1399	++tp;
1400	BUG_ON(tp->token == Opt_onerror_panic);
1401	seq_printf(m: seq, fmt: ",%s", tp->pattern);
1402
1403	mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR;
1404	while (tp->token != Opt_err && tp->token != mval)
1405	++tp;
1406	BUG_ON(tp->token == Opt_err);
1407	seq_printf(m: seq, fmt: ",%s", tp->pattern);
1408
1409	return 0;
1410	}
1411
1412	static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
1413	{
1414	struct super_block *sb = dentry->d_sb;
1415	struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
1416	unsigned flags = UFS_SB(sb)->s_flags;
1417	u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev);
1418
1419	mutex_lock(&UFS_SB(sb)->s_lock);
1420
1421	if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
1422	buf->f_type = UFS2_MAGIC;
1423	else
1424	buf->f_type = UFS_MAGIC;
1425
1426	buf->f_blocks = uspi->s_dsize;
1427	buf->f_bfree = ufs_freefrags(uspi);
1428	buf->f_ffree = uspi->cs_total.cs_nifree;
1429	buf->f_bsize = sb->s_blocksize;
1430	buf->f_bavail = (buf->f_bfree > uspi->s_root_blocks)
1431	? (buf->f_bfree - uspi->s_root_blocks) : 0;
1432	buf->f_files = uspi->s_ncg * uspi->s_ipg;
1433	buf->f_namelen = UFS_MAXNAMLEN;
1434	buf->f_fsid = u64_to_fsid(v: id);
1435
1436	mutex_unlock(lock: &UFS_SB(sb)->s_lock);
1437
1438	return 0;
1439	}
1440
1441	static struct kmem_cache * ufs_inode_cachep;
1442
1443	static struct inode *ufs_alloc_inode(struct super_block *sb)
1444	{
1445	struct ufs_inode_info *ei;
1446
1447	ei = alloc_inode_sb(sb, cache: ufs_inode_cachep, GFP_NOFS);
1448	if (!ei)
1449	return NULL;
1450
1451	inode_set_iversion(inode: &ei->vfs_inode, val: 1);
1452	seqlock_init(&ei->meta_lock);
1453	mutex_init(&ei->truncate_mutex);
1454	return &ei->vfs_inode;
1455	}
1456
1457	static void ufs_free_in_core_inode(struct inode *inode)
1458	{
1459	kmem_cache_free(s: ufs_inode_cachep, objp: UFS_I(inode));
1460	}
1461
1462	static void init_once(void *foo)
1463	{
1464	struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
1465
1466	inode_init_once(&ei->vfs_inode);
1467	}
1468
1469	static int __init init_inodecache(void)
1470	{
1471	ufs_inode_cachep = kmem_cache_create_usercopy(name: "ufs_inode_cache",
1472	size: sizeof(struct ufs_inode_info), align: 0,
1473	flags: (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
1474	SLAB_ACCOUNT),
1475	offsetof(struct ufs_inode_info, i_u1.i_symlink),
1476	sizeof_field(struct ufs_inode_info,
1477	i_u1.i_symlink),
1478	ctor: init_once);
1479	if (ufs_inode_cachep == NULL)
1480	return -ENOMEM;
1481	return 0;
1482	}
1483
1484	static void destroy_inodecache(void)
1485	{
1486	/*
1487	* Make sure all delayed rcu free inodes are flushed before we
1488	* destroy cache.
1489	*/
1490	rcu_barrier();
1491	kmem_cache_destroy(s: ufs_inode_cachep);
1492	}
1493
1494	static const struct super_operations ufs_super_ops = {
1495	.alloc_inode = ufs_alloc_inode,
1496	.free_inode = ufs_free_in_core_inode,
1497	.write_inode = ufs_write_inode,
1498	.evict_inode = ufs_evict_inode,
1499	.put_super = ufs_put_super,
1500	.sync_fs = ufs_sync_fs,
1501	.statfs = ufs_statfs,
1502	.remount_fs = ufs_remount,
1503	.show_options = ufs_show_options,
1504	};
1505
1506	static struct dentry *ufs_mount(struct file_system_type *fs_type,
1507	int flags, const char *dev_name, void *data)
1508	{
1509	return mount_bdev(fs_type, flags, dev_name, data, fill_super: ufs_fill_super);
1510	}
1511
1512	static struct file_system_type ufs_fs_type = {
1513	.owner = THIS_MODULE,
1514	.name = "ufs",
1515	.mount = ufs_mount,
1516	.kill_sb = kill_block_super,
1517	.fs_flags = FS_REQUIRES_DEV,
1518	};
1519	MODULE_ALIAS_FS("ufs");
1520
1521	static int __init init_ufs_fs(void)
1522	{
1523	int err = init_inodecache();
1524	if (err)
1525	goto out1;
1526	err = register_filesystem(&ufs_fs_type);
1527	if (err)
1528	goto out;
1529	return 0;
1530	out:
1531	destroy_inodecache();
1532	out1:
1533	return err;
1534	}
1535
1536	static void __exit exit_ufs_fs(void)
1537	{
1538	unregister_filesystem(&ufs_fs_type);
1539	destroy_inodecache();
1540	}
1541
1542	module_init(init_ufs_fs)
1543	module_exit(exit_ufs_fs)
1544	MODULE_LICENSE("GPL");
1545