1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* linux/fs/fat/dir.c
4	*
5	* directory handling functions for fat-based filesystems
6	*
7	* Written 1992,1993 by Werner Almesberger
8	*
9	* Hidden files 1995 by Albert Cahalan <albert@ccs.neu.edu> <adc@coe.neu.edu>
10	*
11	* VFAT extensions by Gordon Chaffee <chaffee@plateau.cs.berkeley.edu>
12	* Merged with msdos fs by Henrik Storner <storner@osiris.ping.dk>
13	* Rewritten for constant inumbers. Plugged buffer overrun in readdir(). AV
14	* Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
15	*/
16
17	#include <linux/slab.h>
18	#include <linux/compat.h>
19	#include <linux/uaccess.h>
20	#include <linux/iversion.h>
21	#include "fat.h"
22
23	/*
24	* Maximum buffer size of short name.
25	* [(MSDOS_NAME + '.') * max one char + nul]
26	* For msdos style, ['.' (hidden) + MSDOS_NAME + '.' + nul]
27	*/
28	#define FAT_MAX_SHORT_SIZE ((MSDOS_NAME + 1) * NLS_MAX_CHARSET_SIZE + 1)
29	/*
30	* Maximum buffer size of unicode chars from slots.
31	* [(max longname slots * 13 (size in a slot) + nul) * sizeof(wchar_t)]
32	*/
33	#define FAT_MAX_UNI_CHARS ((MSDOS_SLOTS - 1) * 13 + 1)
34	#define FAT_MAX_UNI_SIZE (FAT_MAX_UNI_CHARS * sizeof(wchar_t))
35
36	static inline unsigned char fat_tolower(unsigned char c)
37	{
38	return ((c >= 'A') && (c <= 'Z')) ? c+32 : c;
39	}
40
41	static inline loff_t fat_make_i_pos(struct super_block *sb,
42	struct buffer_head *bh,
43	struct msdos_dir_entry *de)
44	{
45	return ((loff_t)bh->b_blocknr << MSDOS_SB(sb)->dir_per_block_bits)
46	| (de - (struct msdos_dir_entry *)bh->b_data);
47	}
48
49	static inline void fat_dir_readahead(struct inode *dir, sector_t iblock,
50	sector_t phys)
51	{
52	struct super_block *sb = dir->i_sb;
53	struct msdos_sb_info *sbi = MSDOS_SB(sb);
54	struct buffer_head *bh;
55	int sec;
56
57	/* This is not a first sector of cluster, or sec_per_clus == 1 */
58	if ((iblock & (sbi->sec_per_clus - 1)) || sbi->sec_per_clus == 1)
59	return;
60	/* root dir of FAT12/FAT16 */
61	if (!is_fat32(sbi) && (dir->i_ino == MSDOS_ROOT_INO))
62	return;
63
64	bh = sb_find_get_block(sb, block: phys);
65	if (bh == NULL || !buffer_uptodate(bh)) {
66	for (sec = 0; sec < sbi->sec_per_clus; sec++)
67	sb_breadahead(sb, block: phys + sec);
68	}
69	brelse(bh);
70	}
71
72	/* Returns the inode number of the directory entry at offset pos. If bh is
73	non-NULL, it is brelse'd before. Pos is incremented. The buffer header is
74	returned in bh.
75	AV. Most often we do it item-by-item. Makes sense to optimize.
76	AV. OK, there we go: if both bh and de are non-NULL we assume that we just
77	AV. want the next entry (took one explicit de=NULL in vfat/namei.c).
78	AV. It's done in fat_get_entry() (inlined), here the slow case lives.
79	AV. Additionally, when we return -1 (i.e. reached the end of directory)
80	AV. we make bh NULL.
81	*/
82	static int fat__get_entry(struct inode *dir, loff_t *pos,
83	struct buffer_head **bh, struct msdos_dir_entry **de)
84	{
85	struct super_block *sb = dir->i_sb;
86	sector_t phys, iblock;
87	unsigned long mapped_blocks;
88	int err, offset;
89
90	next:
91	brelse(bh: *bh);
92	*bh = NULL;
93	iblock = *pos >> sb->s_blocksize_bits;
94	err = fat_bmap(inode: dir, sector: iblock, phys: &phys, mapped_blocks: &mapped_blocks, create: 0, from_bmap: false);
95	if (err || !phys)
96	return -1; /* beyond EOF or error */
97
98	fat_dir_readahead(dir, iblock, phys);
99
100	*bh = sb_bread(sb, block: phys);
101	if (*bh == NULL) {
102	fat_msg_ratelimit(sb, KERN_ERR,
103	"Directory bread(block %llu) failed", (llu)phys);
104	/* skip this block */
105	*pos = (iblock + 1) << sb->s_blocksize_bits;
106	goto next;
107	}
108
109	offset = *pos & (sb->s_blocksize - 1);
110	*pos += sizeof(struct msdos_dir_entry);
111	*de = (struct msdos_dir_entry *)((*bh)->b_data + offset);
112
113	return 0;
114	}
115
116	static inline int fat_get_entry(struct inode *dir, loff_t *pos,
117	struct buffer_head **bh,
118	struct msdos_dir_entry **de)
119	{
120	/* Fast stuff first */
121	if (*bh && *de &&
122	(*de - (struct msdos_dir_entry *)(*bh)->b_data) <
123	MSDOS_SB(sb: dir->i_sb)->dir_per_block - 1) {
124	*pos += sizeof(struct msdos_dir_entry);
125	(*de)++;
126	return 0;
127	}
128	return fat__get_entry(dir, pos, bh, de);
129	}
130
131	/*
132	* Convert Unicode 16 to UTF-8, translated Unicode, or ASCII.
133	* If uni_xlate is enabled and we can't get a 1:1 conversion, use a
134	* colon as an escape character since it is normally invalid on the vfat
135	* filesystem. The following four characters are the hexadecimal digits
136	* of Unicode value. This lets us do a full dump and restore of Unicode
137	* filenames. We could get into some trouble with long Unicode names,
138	* but ignore that right now.
139	* Ahem... Stack smashing in ring 0 isn't fun. Fixed.
140	*/
141	static int uni16_to_x8(struct super_block *sb, unsigned char *ascii,
142	const wchar_t *uni, int len, struct nls_table *nls)
143	{
144	int uni_xlate = MSDOS_SB(sb)->options.unicode_xlate;
145	const wchar_t *ip;
146	wchar_t ec;
147	unsigned char *op;
148	int charlen;
149
150	ip = uni;
151	op = ascii;
152
153	while (*ip && ((len - NLS_MAX_CHARSET_SIZE) > 0)) {
154	ec = *ip++;
155	charlen = nls->uni2char(ec, op, NLS_MAX_CHARSET_SIZE);
156	if (charlen > 0) {
157	op += charlen;
158	len -= charlen;
159	} else {
160	if (uni_xlate == 1) {
161	*op++ = ':';
162	op = hex_byte_pack(buf: op, byte: ec >> 8);
163	op = hex_byte_pack(buf: op, byte: ec);
164	len -= 5;
165	} else {
166	*op++ = '?';
167	len--;
168	}
169	}
170	}
171
172	if (unlikely(*ip)) {
173	fat_msg(sb, KERN_WARNING,
174	"filename was truncated while converting.");
175	}
176
177	*op = 0;
178	return op - ascii;
179	}
180
181	static inline int fat_uni_to_x8(struct super_block *sb, const wchar_t *uni,
182	unsigned char *buf, int size)
183	{
184	struct msdos_sb_info *sbi = MSDOS_SB(sb);
185	if (sbi->options.utf8)
186	return utf16s_to_utf8s(pwcs: uni, FAT_MAX_UNI_CHARS,
187	endian: UTF16_HOST_ENDIAN, s: buf, maxlen: size);
188	else
189	return uni16_to_x8(sb, ascii: buf, uni, len: size, nls: sbi->nls_io);
190	}
191
192	static inline int
193	fat_short2uni(struct nls_table *t, unsigned char *c, int clen, wchar_t *uni)
194	{
195	int charlen;
196
197	charlen = t->char2uni(c, clen, uni);
198	if (charlen < 0) {
199	*uni = 0x003f; /* a question mark */
200	charlen = 1;
201	}
202	return charlen;
203	}
204
205	static inline int
206	fat_short2lower_uni(struct nls_table *t, unsigned char *c,
207	int clen, wchar_t *uni)
208	{
209	int charlen;
210	wchar_t wc;
211
212	charlen = t->char2uni(c, clen, &wc);
213	if (charlen < 0) {
214	*uni = 0x003f; /* a question mark */
215	charlen = 1;
216	} else if (charlen <= 1) {
217	unsigned char nc = t->charset2lower[*c];
218
219	if (!nc)
220	nc = *c;
221
222	charlen = t->char2uni(&nc, 1, uni);
223	if (charlen < 0) {
224	*uni = 0x003f; /* a question mark */
225	charlen = 1;
226	}
227	} else
228	*uni = wc;
229
230	return charlen;
231	}
232
233	static inline int
234	fat_shortname2uni(struct nls_table *nls, unsigned char *buf, int buf_size,
235	wchar_t *uni_buf, unsigned short opt, int lower)
236	{
237	int len = 0;
238
239	if (opt & VFAT_SFN_DISPLAY_LOWER)
240	len = fat_short2lower_uni(t: nls, c: buf, clen: buf_size, uni: uni_buf);
241	else if (opt & VFAT_SFN_DISPLAY_WIN95)
242	len = fat_short2uni(t: nls, c: buf, clen: buf_size, uni: uni_buf);
243	else if (opt & VFAT_SFN_DISPLAY_WINNT) {
244	if (lower)
245	len = fat_short2lower_uni(t: nls, c: buf, clen: buf_size, uni: uni_buf);
246	else
247	len = fat_short2uni(t: nls, c: buf, clen: buf_size, uni: uni_buf);
248	} else
249	len = fat_short2uni(t: nls, c: buf, clen: buf_size, uni: uni_buf);
250
251	return len;
252	}
253
254	static inline int fat_name_match(struct msdos_sb_info *sbi,
255	const unsigned char *a, int a_len,
256	const unsigned char *b, int b_len)
257	{
258	if (a_len != b_len)
259	return 0;
260
261	if (sbi->options.name_check != 's')
262	return !nls_strnicmp(t: sbi->nls_io, s1: a, s2: b, len: a_len);
263	else
264	return !memcmp(p: a, q: b, size: a_len);
265	}
266
267	enum { PARSE_INVALID = 1, PARSE_NOT_LONGNAME, PARSE_EOF, };
268
269	/**
270	* fat_parse_long - Parse extended directory entry.
271	*
272	* This function returns zero on success, negative value on error, or one of
273	* the following:
274	*
275	* %PARSE_INVALID - Directory entry is invalid.
276	* %PARSE_NOT_LONGNAME - Directory entry does not contain longname.
277	* %PARSE_EOF - Directory has no more entries.
278	*/
279	static int fat_parse_long(struct inode *dir, loff_t *pos,
280	struct buffer_head **bh, struct msdos_dir_entry **de,
281	wchar_t **unicode, unsigned char *nr_slots)
282	{
283	struct msdos_dir_slot *ds;
284	unsigned char id, slot, slots, alias_checksum;
285
286	if (!*unicode) {
287	*unicode = __getname();
288	if (!*unicode) {
289	brelse(bh: *bh);
290	return -ENOMEM;
291	}
292	}
293	parse_long:
294	ds = (struct msdos_dir_slot *)*de;
295	id = ds->id;
296	if (!(id & 0x40))
297	return PARSE_INVALID;
298	slots = id & ~0x40;
299	if (slots > 20 || !slots) /* ceil(256 * 2 / 26) */
300	return PARSE_INVALID;
301	*nr_slots = slots;
302	alias_checksum = ds->alias_checksum;
303
304	slot = slots;
305	while (1) {
306	int offset;
307
308	slot--;
309	offset = slot * 13;
310	fat16_towchar(dst: *unicode + offset, src: ds->name0_4, len: 5);
311	fat16_towchar(dst: *unicode + offset + 5, src: ds->name5_10, len: 6);
312	fat16_towchar(dst: *unicode + offset + 11, src: ds->name11_12, len: 2);
313
314	if (ds->id & 0x40)
315	(*unicode)[offset + 13] = 0;
316	if (fat_get_entry(dir, pos, bh, de) < 0)
317	return PARSE_EOF;
318	if (slot == 0)
319	break;
320	ds = (struct msdos_dir_slot *)*de;
321	if (ds->attr != ATTR_EXT)
322	return PARSE_NOT_LONGNAME;
323	if ((ds->id & ~0x40) != slot)
324	goto parse_long;
325	if (ds->alias_checksum != alias_checksum)
326	goto parse_long;
327	}
328	if ((*de)->name[0] == DELETED_FLAG)
329	return PARSE_INVALID;
330	if ((*de)->attr == ATTR_EXT)
331	goto parse_long;
332	if (IS_FREE((*de)->name) || ((*de)->attr & ATTR_VOLUME))
333	return PARSE_INVALID;
334	if (fat_checksum(name: (*de)->name) != alias_checksum)
335	*nr_slots = 0;
336
337	return 0;
338	}
339
340	/**
341	* fat_parse_short - Parse MS-DOS (short) directory entry.
342	* @sb: superblock
343	* @de: directory entry to parse
344	* @name: FAT_MAX_SHORT_SIZE array in which to place extracted name
345	* @dot_hidden: Nonzero == prepend '.' to names with ATTR_HIDDEN
346	*
347	* Returns the number of characters extracted into 'name'.
348	*/
349	static int fat_parse_short(struct super_block *sb,
350	const struct msdos_dir_entry *de,
351	unsigned char *name, int dot_hidden)
352	{
353	const struct msdos_sb_info *sbi = MSDOS_SB(sb);
354	int isvfat = sbi->options.isvfat;
355	int nocase = sbi->options.nocase;
356	unsigned short opt_shortname = sbi->options.shortname;
357	struct nls_table *nls_disk = sbi->nls_disk;
358	wchar_t uni_name[14];
359	unsigned char c, work[MSDOS_NAME];
360	unsigned char *ptname = name;
361	int chi, chl, i, j, k;
362	int dotoffset = 0;
363	int name_len = 0, uni_len = 0;
364
365	if (!isvfat && dot_hidden && (de->attr & ATTR_HIDDEN)) {
366	*ptname++ = '.';
367	dotoffset = 1;
368	}
369
370	memcpy(work, de->name, sizeof(work));
371	/* For an explanation of the special treatment of 0x05 in
372	* filenames, see msdos_format_name in namei_msdos.c
373	*/
374	if (work[0] == 0x05)
375	work[0] = 0xE5;
376
377	/* Filename */
378	for (i = 0, j = 0; i < 8;) {
379	c = work[i];
380	if (!c)
381	break;
382	chl = fat_shortname2uni(nls: nls_disk, buf: &work[i], buf_size: 8 - i,
383	uni_buf: &uni_name[j++], opt: opt_shortname,
384	lower: de->lcase & CASE_LOWER_BASE);
385	if (chl <= 1) {
386	if (!isvfat)
387	ptname[i] = nocase ? c : fat_tolower(c);
388	i++;
389	if (c != ' ') {
390	name_len = i;
391	uni_len = j;
392	}
393	} else {
394	uni_len = j;
395	if (isvfat)
396	i += min(chl, 8-i);
397	else {
398	for (chi = 0; chi < chl && i < 8; chi++, i++)
399	ptname[i] = work[i];
400	}
401	if (chl)
402	name_len = i;
403	}
404	}
405
406	i = name_len;
407	j = uni_len;
408	fat_short2uni(t: nls_disk, c: ".", clen: 1, uni: &uni_name[j++]);
409	if (!isvfat)
410	ptname[i] = '.';
411	i++;
412
413	/* Extension */
414	for (k = 8; k < MSDOS_NAME;) {
415	c = work[k];
416	if (!c)
417	break;
418	chl = fat_shortname2uni(nls: nls_disk, buf: &work[k], MSDOS_NAME - k,
419	uni_buf: &uni_name[j++], opt: opt_shortname,
420	lower: de->lcase & CASE_LOWER_EXT);
421	if (chl <= 1) {
422	k++;
423	if (!isvfat)
424	ptname[i] = nocase ? c : fat_tolower(c);
425	i++;
426	if (c != ' ') {
427	name_len = i;
428	uni_len = j;
429	}
430	} else {
431	uni_len = j;
432	if (isvfat) {
433	int offset = min(chl, MSDOS_NAME-k);
434	k += offset;
435	i += offset;
436	} else {
437	for (chi = 0; chi < chl && k < MSDOS_NAME;
438	chi++, i++, k++) {
439	ptname[i] = work[k];
440	}
441	}
442	if (chl)
443	name_len = i;
444	}
445	}
446
447	if (name_len > 0) {
448	name_len += dotoffset;
449
450	if (sbi->options.isvfat) {
451	uni_name[uni_len] = 0x0000;
452	name_len = fat_uni_to_x8(sb, uni: uni_name, buf: name,
453	FAT_MAX_SHORT_SIZE);
454	}
455	}
456
457	return name_len;
458	}
459
460	/*
461	* Return values: negative -> error/not found, 0 -> found.
462	*/
463	int fat_search_long(struct inode *inode, const unsigned char *name,
464	int name_len, struct fat_slot_info *sinfo)
465	{
466	struct super_block *sb = inode->i_sb;
467	struct msdos_sb_info *sbi = MSDOS_SB(sb);
468	struct buffer_head *bh = NULL;
469	struct msdos_dir_entry *de;
470	unsigned char nr_slots;
471	wchar_t *unicode = NULL;
472	unsigned char bufname[FAT_MAX_SHORT_SIZE];
473	loff_t cpos = 0;
474	int err, len;
475
476	err = -ENOENT;
477	while (1) {
478	if (fat_get_entry(dir: inode, pos: &cpos, bh: &bh, de: &de) == -1)
479	goto end_of_dir;
480	parse_record:
481	nr_slots = 0;
482	if (de->name[0] == DELETED_FLAG)
483	continue;
484	if (de->attr != ATTR_EXT && (de->attr & ATTR_VOLUME))
485	continue;
486	if (de->attr != ATTR_EXT && IS_FREE(de->name))
487	continue;
488	if (de->attr == ATTR_EXT) {
489	int status = fat_parse_long(dir: inode, pos: &cpos, bh: &bh, de: &de,
490	unicode: &unicode, nr_slots: &nr_slots);
491	if (status < 0) {
492	err = status;
493	goto end_of_dir;
494	} else if (status == PARSE_INVALID)
495	continue;
496	else if (status == PARSE_NOT_LONGNAME)
497	goto parse_record;
498	else if (status == PARSE_EOF)
499	goto end_of_dir;
500	}
501
502	/* Never prepend '.' to hidden files here.
503	* That is done only for msdos mounts (and only when
504	* 'dotsOK=yes'); if we are executing here, it is in the
505	* context of a vfat mount.
506	*/
507	len = fat_parse_short(sb, de, name: bufname, dot_hidden: 0);
508	if (len == 0)
509	continue;
510
511	/* Compare shortname */
512	if (fat_name_match(sbi, a: name, a_len: name_len, b: bufname, b_len: len))
513	goto found;
514
515	if (nr_slots) {
516	void *longname = unicode + FAT_MAX_UNI_CHARS;
517	int size = PATH_MAX - FAT_MAX_UNI_SIZE;
518
519	/* Compare longname */
520	len = fat_uni_to_x8(sb, uni: unicode, buf: longname, size);
521	if (fat_name_match(sbi, a: name, a_len: name_len, b: longname, b_len: len))
522	goto found;
523	}
524	}
525
526	found:
527	nr_slots++; /* include the de */
528	sinfo->slot_off = cpos - nr_slots * sizeof(*de);
529	sinfo->nr_slots = nr_slots;
530	sinfo->de = de;
531	sinfo->bh = bh;
532	sinfo->i_pos = fat_make_i_pos(sb, bh: sinfo->bh, de: sinfo->de);
533	err = 0;
534	end_of_dir:
535	if (unicode)
536	__putname(unicode);
537
538	return err;
539	}
540	EXPORT_SYMBOL_GPL(fat_search_long);
541
542	struct fat_ioctl_filldir_callback {
543	struct dir_context ctx;
544	void __user *dirent;
545	int result;
546	/* for dir ioctl */
547	const char *longname;
548	int long_len;
549	const char *shortname;
550	int short_len;
551	};
552
553	static int __fat_readdir(struct inode *inode, struct file *file,
554	struct dir_context *ctx, int short_only,
555	struct fat_ioctl_filldir_callback *both)
556	{
557	struct super_block *sb = inode->i_sb;
558	struct msdos_sb_info *sbi = MSDOS_SB(sb);
559	struct buffer_head *bh;
560	struct msdos_dir_entry *de;
561	unsigned char nr_slots;
562	wchar_t *unicode = NULL;
563	unsigned char bufname[FAT_MAX_SHORT_SIZE];
564	int isvfat = sbi->options.isvfat;
565	const char *fill_name = NULL;
566	int fake_offset = 0;
567	loff_t cpos;
568	int short_len = 0, fill_len = 0;
569	int ret = 0;
570
571	mutex_lock(&sbi->s_lock);
572
573	cpos = ctx->pos;
574	/* Fake . and .. for the root directory. */
575	if (inode->i_ino == MSDOS_ROOT_INO) {
576	if (!dir_emit_dots(file, ctx))
577	goto out;
578	if (ctx->pos == 2) {
579	fake_offset = 1;
580	cpos = 0;
581	}
582	}
583	if (cpos & (sizeof(struct msdos_dir_entry) - 1)) {
584	ret = -ENOENT;
585	goto out;
586	}
587
588	bh = NULL;
589	get_new:
590	if (fat_get_entry(dir: inode, pos: &cpos, bh: &bh, de: &de) == -1)
591	goto end_of_dir;
592	parse_record:
593	nr_slots = 0;
594	/*
595	* Check for long filename entry, but if short_only, we don't
596	* need to parse long filename.
597	*/
598	if (isvfat && !short_only) {
599	if (de->name[0] == DELETED_FLAG)
600	goto record_end;
601	if (de->attr != ATTR_EXT && (de->attr & ATTR_VOLUME))
602	goto record_end;
603	if (de->attr != ATTR_EXT && IS_FREE(de->name))
604	goto record_end;
605	} else {
606	if ((de->attr & ATTR_VOLUME) || IS_FREE(de->name))
607	goto record_end;
608	}
609
610	if (isvfat && de->attr == ATTR_EXT) {
611	int status = fat_parse_long(dir: inode, pos: &cpos, bh: &bh, de: &de,
612	unicode: &unicode, nr_slots: &nr_slots);
613	if (status < 0) {
614	bh = NULL;
615	ret = status;
616	goto end_of_dir;
617	} else if (status == PARSE_INVALID)
618	goto record_end;
619	else if (status == PARSE_NOT_LONGNAME)
620	goto parse_record;
621	else if (status == PARSE_EOF)
622	goto end_of_dir;
623
624	if (nr_slots) {
625	void *longname = unicode + FAT_MAX_UNI_CHARS;
626	int size = PATH_MAX - FAT_MAX_UNI_SIZE;
627	int len = fat_uni_to_x8(sb, uni: unicode, buf: longname, size);
628
629	fill_name = longname;
630	fill_len = len;
631	/* !both && !short_only, so we don't need shortname. */
632	if (!both)
633	goto start_filldir;
634
635	short_len = fat_parse_short(sb, de, name: bufname,
636	dot_hidden: sbi->options.dotsOK);
637	if (short_len == 0)
638	goto record_end;
639	/* hack for fat_ioctl_filldir() */
640	both->longname = fill_name;
641	both->long_len = fill_len;
642	both->shortname = bufname;
643	both->short_len = short_len;
644	fill_name = NULL;
645	fill_len = 0;
646	goto start_filldir;
647	}
648	}
649
650	short_len = fat_parse_short(sb, de, name: bufname, dot_hidden: sbi->options.dotsOK);
651	if (short_len == 0)
652	goto record_end;
653
654	fill_name = bufname;
655	fill_len = short_len;
656
657	start_filldir:
658	ctx->pos = cpos - (nr_slots + 1) * sizeof(struct msdos_dir_entry);
659	if (fake_offset && ctx->pos < 2)
660	ctx->pos = 2;
661
662	if (!memcmp(p: de->name, MSDOS_DOT, MSDOS_NAME)) {
663	if (!dir_emit_dot(file, ctx))
664	goto fill_failed;
665	} else if (!memcmp(p: de->name, MSDOS_DOTDOT, MSDOS_NAME)) {
666	if (!dir_emit_dotdot(file, ctx))
667	goto fill_failed;
668	} else {
669	unsigned long inum;
670	loff_t i_pos = fat_make_i_pos(sb, bh, de);
671	struct inode *tmp = fat_iget(sb, i_pos);
672	if (tmp) {
673	inum = tmp->i_ino;
674	iput(tmp);
675	} else
676	inum = iunique(sb, MSDOS_ROOT_INO);
677	if (!dir_emit(ctx, name: fill_name, namelen: fill_len, ino: inum,
678	type: (de->attr & ATTR_DIR) ? DT_DIR : DT_REG))
679	goto fill_failed;
680	}
681
682	record_end:
683	fake_offset = 0;
684	ctx->pos = cpos;
685	goto get_new;
686
687	end_of_dir:
688	if (fake_offset && cpos < 2)
689	ctx->pos = 2;
690	else
691	ctx->pos = cpos;
692	fill_failed:
693	brelse(bh);
694	if (unicode)
695	__putname(unicode);
696	out:
697	mutex_unlock(lock: &sbi->s_lock);
698
699	return ret;
700	}
701
702	static int fat_readdir(struct file *file, struct dir_context *ctx)
703	{
704	return __fat_readdir(inode: file_inode(f: file), file, ctx, short_only: 0, NULL);
705	}
706
707	#define FAT_IOCTL_FILLDIR_FUNC(func, dirent_type) \
708	static bool func(struct dir_context *ctx, const char *name, int name_len, \
709	loff_t offset, u64 ino, unsigned int d_type) \
710	{ \
711	struct fat_ioctl_filldir_callback *buf = \
712	container_of(ctx, struct fat_ioctl_filldir_callback, ctx); \
713	struct dirent_type __user *d1 = buf->dirent; \
714	struct dirent_type __user *d2 = d1 + 1; \
715	\
716	if (buf->result) \
717	return false; \
718	buf->result++; \
719	\
720	if (name != NULL) { \
721	/* dirent has only short name */ \
722	if (name_len >= sizeof(d1->d_name)) \
723	name_len = sizeof(d1->d_name) - 1; \
724	\
725	if (put_user(0, &d2->d_name[0]) || \
726	put_user(0, &d2->d_reclen) || \
727	copy_to_user(d1->d_name, name, name_len) || \
728	put_user(0, d1->d_name + name_len) || \
729	put_user(name_len, &d1->d_reclen)) \
730	goto efault; \
731	} else { \
732	/* dirent has short and long name */ \
733	const char *longname = buf->longname; \
734	int long_len = buf->long_len; \
735	const char *shortname = buf->shortname; \
736	int short_len = buf->short_len; \
737	\
738	if (long_len >= sizeof(d1->d_name)) \
739	long_len = sizeof(d1->d_name) - 1; \
740	if (short_len >= sizeof(d1->d_name)) \
741	short_len = sizeof(d1->d_name) - 1; \
742	\
743	if (copy_to_user(d2->d_name, longname, long_len) || \
744	put_user(0, d2->d_name + long_len) || \
745	put_user(long_len, &d2->d_reclen) || \
746	put_user(ino, &d2->d_ino) || \
747	put_user(offset, &d2->d_off) || \
748	copy_to_user(d1->d_name, shortname, short_len) || \
749	put_user(0, d1->d_name + short_len) || \
750	put_user(short_len, &d1->d_reclen)) \
751	goto efault; \
752	} \
753	return true; \
754	efault: \
755	buf->result = -EFAULT; \
756	return false; \
757	}
758
759	FAT_IOCTL_FILLDIR_FUNC(fat_ioctl_filldir, __fat_dirent)
760
761	static int fat_ioctl_readdir(struct inode *inode, struct file *file,
762	void __user *dirent, filldir_t filldir,
763	int short_only, int both)
764	{
765	struct fat_ioctl_filldir_callback buf = {
766	.ctx.actor = filldir,
767	.dirent = dirent
768	};
769	int ret;
770
771	buf.dirent = dirent;
772	buf.result = 0;
773	inode_lock_shared(inode);
774	buf.ctx.pos = file->f_pos;
775	ret = -ENOENT;
776	if (!IS_DEADDIR(inode)) {
777	ret = __fat_readdir(inode, file, ctx: &buf.ctx,
778	short_only, both: both ? &buf : NULL);
779	file->f_pos = buf.ctx.pos;
780	}
781	inode_unlock_shared(inode);
782	if (ret >= 0)
783	ret = buf.result;
784	return ret;
785	}
786
787	static long fat_dir_ioctl(struct file *filp, unsigned int cmd,
788	unsigned long arg)
789	{
790	struct inode *inode = file_inode(f: filp);
791	struct __fat_dirent __user *d1 = (struct __fat_dirent __user *)arg;
792	int short_only, both;
793
794	switch (cmd) {
795	case VFAT_IOCTL_READDIR_SHORT:
796	short_only = 1;
797	both = 0;
798	break;
799	case VFAT_IOCTL_READDIR_BOTH:
800	short_only = 0;
801	both = 1;
802	break;
803	default:
804	return fat_generic_ioctl(filp, cmd, arg);
805	}
806
807	/*
808	* Yes, we don't need this put_user() absolutely. However old
809	* code didn't return the right value. So, app use this value,
810	* in order to check whether it is EOF.
811	*/
812	if (put_user(0, &d1->d_reclen))
813	return -EFAULT;
814
815	return fat_ioctl_readdir(inode, file: filp, dirent: d1, filldir: fat_ioctl_filldir,
816	short_only, both);
817	}
818
819	#ifdef CONFIG_COMPAT
820	#define VFAT_IOCTL_READDIR_BOTH32 _IOR('r', 1, struct compat_dirent[2])
821	#define VFAT_IOCTL_READDIR_SHORT32 _IOR('r', 2, struct compat_dirent[2])
822
823	FAT_IOCTL_FILLDIR_FUNC(fat_compat_ioctl_filldir, compat_dirent)
824
825	static long fat_compat_dir_ioctl(struct file *filp, unsigned cmd,
826	unsigned long arg)
827	{
828	struct inode *inode = file_inode(f: filp);
829	struct compat_dirent __user *d1 = compat_ptr(uptr: arg);
830	int short_only, both;
831
832	switch (cmd) {
833	case VFAT_IOCTL_READDIR_SHORT32:
834	short_only = 1;
835	both = 0;
836	break;
837	case VFAT_IOCTL_READDIR_BOTH32:
838	short_only = 0;
839	both = 1;
840	break;
841	default:
842	return fat_generic_ioctl(filp, cmd, arg: (unsigned long)arg);
843	}
844
845	/*
846	* Yes, we don't need this put_user() absolutely. However old
847	* code didn't return the right value. So, app use this value,
848	* in order to check whether it is EOF.
849	*/
850	if (put_user(0, &d1->d_reclen))
851	return -EFAULT;
852
853	return fat_ioctl_readdir(inode, file: filp, dirent: d1, filldir: fat_compat_ioctl_filldir,
854	short_only, both);
855	}
856	#endif /* CONFIG_COMPAT */
857
858	const struct file_operations fat_dir_operations = {
859	.llseek = generic_file_llseek,
860	.read = generic_read_dir,
861	.iterate_shared = fat_readdir,
862	.unlocked_ioctl = fat_dir_ioctl,
863	#ifdef CONFIG_COMPAT
864	.compat_ioctl = fat_compat_dir_ioctl,
865	#endif
866	.fsync = fat_file_fsync,
867	};
868
869	static int fat_get_short_entry(struct inode *dir, loff_t *pos,
870	struct buffer_head **bh,
871	struct msdos_dir_entry **de)
872	{
873	while (fat_get_entry(dir, pos, bh, de) >= 0) {
874	/* free entry or long name entry or volume label */
875	if (!IS_FREE((*de)->name) && !((*de)->attr & ATTR_VOLUME))
876	return 0;
877	}
878	return -ENOENT;
879	}
880
881	/*
882	* The ".." entry can not provide the "struct fat_slot_info" information
883	* for inode, nor a usable i_pos. So, this function provides some information
884	* only.
885	*
886	* Since this function walks through the on-disk inodes within a directory,
887	* callers are responsible for taking any locks necessary to prevent the
888	* directory from changing.
889	*/
890	int fat_get_dotdot_entry(struct inode *dir, struct buffer_head **bh,
891	struct msdos_dir_entry **de)
892	{
893	loff_t offset = 0;
894
895	*de = NULL;
896	while (fat_get_short_entry(dir, pos: &offset, bh, de) >= 0) {
897	if (!strncmp((*de)->name, MSDOS_DOTDOT, MSDOS_NAME))
898	return 0;
899	}
900	return -ENOENT;
901	}
902	EXPORT_SYMBOL_GPL(fat_get_dotdot_entry);
903
904	/* See if directory is empty */
905	int fat_dir_empty(struct inode *dir)
906	{
907	struct buffer_head *bh;
908	struct msdos_dir_entry *de;
909	loff_t cpos;
910	int result = 0;
911
912	bh = NULL;
913	cpos = 0;
914	while (fat_get_short_entry(dir, pos: &cpos, bh: &bh, de: &de) >= 0) {
915	if (strncmp(de->name, MSDOS_DOT , MSDOS_NAME) &&
916	strncmp(de->name, MSDOS_DOTDOT, MSDOS_NAME)) {
917	result = -ENOTEMPTY;
918	break;
919	}
920	}
921	brelse(bh);
922	return result;
923	}
924	EXPORT_SYMBOL_GPL(fat_dir_empty);
925
926	/*
927	* fat_subdirs counts the number of sub-directories of dir. It can be run
928	* on directories being created.
929	*/
930	int fat_subdirs(struct inode *dir)
931	{
932	struct buffer_head *bh;
933	struct msdos_dir_entry *de;
934	loff_t cpos;
935	int count = 0;
936
937	bh = NULL;
938	cpos = 0;
939	while (fat_get_short_entry(dir, pos: &cpos, bh: &bh, de: &de) >= 0) {
940	if (de->attr & ATTR_DIR)
941	count++;
942	}
943	brelse(bh);
944	return count;
945	}
946
947	/*
948	* Scans a directory for a given file (name points to its formatted name).
949	* Returns an error code or zero.
950	*/
951	int fat_scan(struct inode *dir, const unsigned char *name,
952	struct fat_slot_info *sinfo)
953	{
954	struct super_block *sb = dir->i_sb;
955
956	sinfo->slot_off = 0;
957	sinfo->bh = NULL;
958	while (fat_get_short_entry(dir, pos: &sinfo->slot_off, bh: &sinfo->bh,
959	de: &sinfo->de) >= 0) {
960	if (!strncmp(sinfo->de->name, name, MSDOS_NAME)) {
961	sinfo->slot_off -= sizeof(*sinfo->de);
962	sinfo->nr_slots = 1;
963	sinfo->i_pos = fat_make_i_pos(sb, bh: sinfo->bh, de: sinfo->de);
964	return 0;
965	}
966	}
967	return -ENOENT;
968	}
969	EXPORT_SYMBOL_GPL(fat_scan);
970
971	/*
972	* Scans a directory for a given logstart.
973	* Returns an error code or zero.
974	*/
975	int fat_scan_logstart(struct inode *dir, int i_logstart,
976	struct fat_slot_info *sinfo)
977	{
978	struct super_block *sb = dir->i_sb;
979
980	sinfo->slot_off = 0;
981	sinfo->bh = NULL;
982	while (fat_get_short_entry(dir, pos: &sinfo->slot_off, bh: &sinfo->bh,
983	de: &sinfo->de) >= 0) {
984	if (fat_get_start(sbi: MSDOS_SB(sb), de: sinfo->de) == i_logstart) {
985	sinfo->slot_off -= sizeof(*sinfo->de);
986	sinfo->nr_slots = 1;
987	sinfo->i_pos = fat_make_i_pos(sb, bh: sinfo->bh, de: sinfo->de);
988	return 0;
989	}
990	}
991	return -ENOENT;
992	}
993
994	static int __fat_remove_entries(struct inode *dir, loff_t pos, int nr_slots)
995	{
996	struct super_block *sb = dir->i_sb;
997	struct buffer_head *bh;
998	struct msdos_dir_entry *de, *endp;
999	int err = 0, orig_slots;
1000
1001	while (nr_slots) {
1002	bh = NULL;
1003	if (fat_get_entry(dir, pos: &pos, bh: &bh, de: &de) < 0) {
1004	err = -EIO;
1005	break;
1006	}
1007
1008	orig_slots = nr_slots;
1009	endp = (struct msdos_dir_entry *)(bh->b_data + sb->s_blocksize);
1010	while (nr_slots && de < endp) {
1011	de->name[0] = DELETED_FLAG;
1012	de++;
1013	nr_slots--;
1014	}
1015	mark_buffer_dirty_inode(bh, inode: dir);
1016	if (IS_DIRSYNC(dir))
1017	err = sync_dirty_buffer(bh);
1018	brelse(bh);
1019	if (err)
1020	break;
1021
1022	/* pos is *next* de's position, so this does `- sizeof(de)' */
1023	pos += ((orig_slots - nr_slots) * sizeof(*de)) - sizeof(*de);
1024	}
1025
1026	return err;
1027	}
1028
1029	int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)
1030	{
1031	struct super_block *sb = dir->i_sb;
1032	struct msdos_dir_entry *de;
1033	struct buffer_head *bh;
1034	int err = 0, nr_slots;
1035
1036	/*
1037	* First stage: Remove the shortname. By this, the directory
1038	* entry is removed.
1039	*/
1040	nr_slots = sinfo->nr_slots;
1041	de = sinfo->de;
1042	sinfo->de = NULL;
1043	bh = sinfo->bh;
1044	sinfo->bh = NULL;
1045	while (nr_slots && de >= (struct msdos_dir_entry *)bh->b_data) {
1046	de->name[0] = DELETED_FLAG;
1047	de--;
1048	nr_slots--;
1049	}
1050	mark_buffer_dirty_inode(bh, inode: dir);
1051	if (IS_DIRSYNC(dir))
1052	err = sync_dirty_buffer(bh);
1053	brelse(bh);
1054	if (err)
1055	return err;
1056	inode_inc_iversion(inode: dir);
1057
1058	if (nr_slots) {
1059	/*
1060	* Second stage: remove the remaining longname slots.
1061	* (This directory entry is already removed, and so return
1062	* the success)
1063	*/
1064	err = __fat_remove_entries(dir, pos: sinfo->slot_off, nr_slots);
1065	if (err) {
1066	fat_msg(sb, KERN_WARNING,
1067	"Couldn't remove the long name slots");
1068	}
1069	}
1070
1071	fat_truncate_time(inode: dir, NULL, flags: S_ATIME|S_MTIME);
1072	if (IS_DIRSYNC(dir))
1073	(void)fat_sync_inode(inode: dir);
1074	else
1075	mark_inode_dirty(inode: dir);
1076
1077	return 0;
1078	}
1079	EXPORT_SYMBOL_GPL(fat_remove_entries);
1080
1081	static int fat_zeroed_cluster(struct inode *dir, sector_t blknr, int nr_used,
1082	struct buffer_head **bhs, int nr_bhs)
1083	{
1084	struct super_block *sb = dir->i_sb;
1085	sector_t last_blknr = blknr + MSDOS_SB(sb)->sec_per_clus;
1086	int err, i, n;
1087
1088	/* Zeroing the unused blocks on this cluster */
1089	blknr += nr_used;
1090	n = nr_used;
1091	while (blknr < last_blknr) {
1092	bhs[n] = sb_getblk(sb, block: blknr);
1093	if (!bhs[n]) {
1094	err = -ENOMEM;
1095	goto error;
1096	}
1097	/* Avoid race with userspace read via bdev */
1098	lock_buffer(bh: bhs[n]);
1099	memset(bhs[n]->b_data, 0, sb->s_blocksize);
1100	set_buffer_uptodate(bhs[n]);
1101	unlock_buffer(bh: bhs[n]);
1102	mark_buffer_dirty_inode(bh: bhs[n], inode: dir);
1103
1104	n++;
1105	blknr++;
1106	if (n == nr_bhs) {
1107	if (IS_DIRSYNC(dir)) {
1108	err = fat_sync_bhs(bhs, nr_bhs: n);
1109	if (err)
1110	goto error;
1111	}
1112	for (i = 0; i < n; i++)
1113	brelse(bh: bhs[i]);
1114	n = 0;
1115	}
1116	}
1117	if (IS_DIRSYNC(dir)) {
1118	err = fat_sync_bhs(bhs, nr_bhs: n);
1119	if (err)
1120	goto error;
1121	}
1122	for (i = 0; i < n; i++)
1123	brelse(bh: bhs[i]);
1124
1125	return 0;
1126
1127	error:
1128	for (i = 0; i < n; i++)
1129	bforget(bh: bhs[i]);
1130	return err;
1131	}
1132
1133	int fat_alloc_new_dir(struct inode *dir, struct timespec64 *ts)
1134	{
1135	struct super_block *sb = dir->i_sb;
1136	struct msdos_sb_info *sbi = MSDOS_SB(sb);
1137	struct buffer_head *bhs[MAX_BUF_PER_PAGE];
1138	struct msdos_dir_entry *de;
1139	sector_t blknr;
1140	__le16 date, time;
1141	u8 time_cs;
1142	int err, cluster;
1143
1144	err = fat_alloc_clusters(inode: dir, cluster: &cluster, nr_cluster: 1);
1145	if (err)
1146	goto error;
1147
1148	blknr = fat_clus_to_blknr(sbi, clus: cluster);
1149	bhs[0] = sb_getblk(sb, block: blknr);
1150	if (!bhs[0]) {
1151	err = -ENOMEM;
1152	goto error_free;
1153	}
1154
1155	fat_time_unix2fat(sbi, ts, time: &time, date: &date, time_cs: &time_cs);
1156
1157	de = (struct msdos_dir_entry *)bhs[0]->b_data;
1158	/* Avoid race with userspace read via bdev */
1159	lock_buffer(bh: bhs[0]);
1160	/* filling the new directory slots ("." and ".." entries) */
1161	memcpy(de[0].name, MSDOS_DOT, MSDOS_NAME);
1162	memcpy(de[1].name, MSDOS_DOTDOT, MSDOS_NAME);
1163	de->attr = de[1].attr = ATTR_DIR;
1164	de[0].lcase = de[1].lcase = 0;
1165	de[0].time = de[1].time = time;
1166	de[0].date = de[1].date = date;
1167	if (sbi->options.isvfat) {
1168	/* extra timestamps */
1169	de[0].ctime = de[1].ctime = time;
1170	de[0].ctime_cs = de[1].ctime_cs = time_cs;
1171	de[0].adate = de[0].cdate = de[1].adate = de[1].cdate = date;
1172	} else {
1173	de[0].ctime = de[1].ctime = 0;
1174	de[0].ctime_cs = de[1].ctime_cs = 0;
1175	de[0].adate = de[0].cdate = de[1].adate = de[1].cdate = 0;
1176	}
1177	fat_set_start(de: &de[0], cluster);
1178	fat_set_start(de: &de[1], cluster: MSDOS_I(inode: dir)->i_logstart);
1179	de[0].size = de[1].size = 0;
1180	memset(de + 2, 0, sb->s_blocksize - 2 * sizeof(*de));
1181	set_buffer_uptodate(bhs[0]);
1182	unlock_buffer(bh: bhs[0]);
1183	mark_buffer_dirty_inode(bh: bhs[0], inode: dir);
1184
1185	err = fat_zeroed_cluster(dir, blknr, nr_used: 1, bhs, MAX_BUF_PER_PAGE);
1186	if (err)
1187	goto error_free;
1188
1189	return cluster;
1190
1191	error_free:
1192	fat_free_clusters(inode: dir, cluster);
1193	error:
1194	return err;
1195	}
1196	EXPORT_SYMBOL_GPL(fat_alloc_new_dir);
1197
1198	static int fat_add_new_entries(struct inode *dir, void *slots, int nr_slots,
1199	int *nr_cluster, struct msdos_dir_entry **de,
1200	struct buffer_head **bh, loff_t *i_pos)
1201	{
1202	struct super_block *sb = dir->i_sb;
1203	struct msdos_sb_info *sbi = MSDOS_SB(sb);
1204	struct buffer_head *bhs[MAX_BUF_PER_PAGE];
1205	sector_t blknr, start_blknr, last_blknr;
1206	unsigned long size, copy;
1207	int err, i, n, offset, cluster[2];
1208
1209	/*
1210	* The minimum cluster size is 512bytes, and maximum entry
1211	* size is 32*slots (672bytes). So, iff the cluster size is
1212	* 512bytes, we may need two clusters.
1213	*/
1214	size = nr_slots * sizeof(struct msdos_dir_entry);
1215	*nr_cluster = (size + (sbi->cluster_size - 1)) >> sbi->cluster_bits;
1216	BUG_ON(*nr_cluster > 2);
1217
1218	err = fat_alloc_clusters(inode: dir, cluster, nr_cluster: *nr_cluster);
1219	if (err)
1220	goto error;
1221
1222	/*
1223	* First stage: Fill the directory entry. NOTE: This cluster
1224	* is not referenced from any inode yet, so updates order is
1225	* not important.
1226	*/
1227	i = n = copy = 0;
1228	do {
1229	start_blknr = blknr = fat_clus_to_blknr(sbi, clus: cluster[i]);
1230	last_blknr = start_blknr + sbi->sec_per_clus;
1231	while (blknr < last_blknr) {
1232	bhs[n] = sb_getblk(sb, block: blknr);
1233	if (!bhs[n]) {
1234	err = -ENOMEM;
1235	goto error_nomem;
1236	}
1237
1238	/* fill the directory entry */
1239	copy = min(size, sb->s_blocksize);
1240	/* Avoid race with userspace read via bdev */
1241	lock_buffer(bh: bhs[n]);
1242	memcpy(bhs[n]->b_data, slots, copy);
1243	set_buffer_uptodate(bhs[n]);
1244	unlock_buffer(bh: bhs[n]);
1245	mark_buffer_dirty_inode(bh: bhs[n], inode: dir);
1246	slots += copy;
1247	size -= copy;
1248	if (!size)
1249	break;
1250	n++;
1251	blknr++;
1252	}
1253	} while (++i < *nr_cluster);
1254
1255	memset(bhs[n]->b_data + copy, 0, sb->s_blocksize - copy);
1256	offset = copy - sizeof(struct msdos_dir_entry);
1257	get_bh(bh: bhs[n]);
1258	*bh = bhs[n];
1259	*de = (struct msdos_dir_entry *)((*bh)->b_data + offset);
1260	*i_pos = fat_make_i_pos(sb, bh: *bh, de: *de);
1261
1262	/* Second stage: clear the rest of cluster, and write outs */
1263	err = fat_zeroed_cluster(dir, blknr: start_blknr, nr_used: ++n, bhs, MAX_BUF_PER_PAGE);
1264	if (err)
1265	goto error_free;
1266
1267	return cluster[0];
1268
1269	error_free:
1270	brelse(bh: *bh);
1271	*bh = NULL;
1272	n = 0;
1273	error_nomem:
1274	for (i = 0; i < n; i++)
1275	bforget(bh: bhs[i]);
1276	fat_free_clusters(inode: dir, cluster: cluster[0]);
1277	error:
1278	return err;
1279	}
1280
1281	int fat_add_entries(struct inode *dir, void *slots, int nr_slots,
1282	struct fat_slot_info *sinfo)
1283	{
1284	struct super_block *sb = dir->i_sb;
1285	struct msdos_sb_info *sbi = MSDOS_SB(sb);
1286	struct buffer_head *bh, *prev, *bhs[3]; /* 32*slots (672bytes) */
1287	struct msdos_dir_entry *de;
1288	int err, free_slots, i, nr_bhs;
1289	loff_t pos, i_pos;
1290
1291	sinfo->nr_slots = nr_slots;
1292
1293	/* First stage: search free directory entries */
1294	free_slots = nr_bhs = 0;
1295	bh = prev = NULL;
1296	pos = 0;
1297	err = -ENOSPC;
1298	while (fat_get_entry(dir, pos: &pos, bh: &bh, de: &de) > -1) {
1299	/* check the maximum size of directory */
1300	if (pos >= FAT_MAX_DIR_SIZE)
1301	goto error;
1302
1303	if (IS_FREE(de->name)) {
1304	if (prev != bh) {
1305	get_bh(bh);
1306	bhs[nr_bhs] = prev = bh;
1307	nr_bhs++;
1308	}
1309	free_slots++;
1310	if (free_slots == nr_slots)
1311	goto found;
1312	} else {
1313	for (i = 0; i < nr_bhs; i++)
1314	brelse(bh: bhs[i]);
1315	prev = NULL;
1316	free_slots = nr_bhs = 0;
1317	}
1318	}
1319	if (dir->i_ino == MSDOS_ROOT_INO) {
1320	if (!is_fat32(sbi))
1321	goto error;
1322	} else if (MSDOS_I(inode: dir)->i_start == 0) {
1323	fat_msg(sb, KERN_ERR, "Corrupted directory (i_pos %lld)",
1324	MSDOS_I(dir)->i_pos);
1325	err = -EIO;
1326	goto error;
1327	}
1328
1329	found:
1330	err = 0;
1331	pos -= free_slots * sizeof(*de);
1332	nr_slots -= free_slots;
1333	if (free_slots) {
1334	/*
1335	* Second stage: filling the free entries with new entries.
1336	* NOTE: If this slots has shortname, first, we write
1337	* the long name slots, then write the short name.
1338	*/
1339	int size = free_slots * sizeof(*de);
1340	int offset = pos & (sb->s_blocksize - 1);
1341	int long_bhs = nr_bhs - (nr_slots == 0);
1342
1343	/* Fill the long name slots. */
1344	for (i = 0; i < long_bhs; i++) {
1345	int copy = min_t(int, sb->s_blocksize - offset, size);
1346	memcpy(bhs[i]->b_data + offset, slots, copy);
1347	mark_buffer_dirty_inode(bh: bhs[i], inode: dir);
1348	offset = 0;
1349	slots += copy;
1350	size -= copy;
1351	}
1352	if (long_bhs && IS_DIRSYNC(dir))
1353	err = fat_sync_bhs(bhs, nr_bhs: long_bhs);
1354	if (!err && i < nr_bhs) {
1355	/* Fill the short name slot. */
1356	int copy = min_t(int, sb->s_blocksize - offset, size);
1357	memcpy(bhs[i]->b_data + offset, slots, copy);
1358	mark_buffer_dirty_inode(bh: bhs[i], inode: dir);
1359	if (IS_DIRSYNC(dir))
1360	err = sync_dirty_buffer(bh: bhs[i]);
1361	}
1362	for (i = 0; i < nr_bhs; i++)
1363	brelse(bh: bhs[i]);
1364	if (err)
1365	goto error_remove;
1366	}
1367
1368	if (nr_slots) {
1369	int cluster, nr_cluster;
1370
1371	/*
1372	* Third stage: allocate the cluster for new entries.
1373	* And initialize the cluster with new entries, then
1374	* add the cluster to dir.
1375	*/
1376	cluster = fat_add_new_entries(dir, slots, nr_slots, nr_cluster: &nr_cluster,
1377	de: &de, bh: &bh, i_pos: &i_pos);
1378	if (cluster < 0) {
1379	err = cluster;
1380	goto error_remove;
1381	}
1382	err = fat_chain_add(inode: dir, new_dclus: cluster, nr_cluster);
1383	if (err) {
1384	fat_free_clusters(inode: dir, cluster);
1385	goto error_remove;
1386	}
1387	if (dir->i_size & (sbi->cluster_size - 1)) {
1388	fat_fs_error(sb, "Odd directory size");
1389	dir->i_size = (dir->i_size + sbi->cluster_size - 1)
1390	& ~((loff_t)sbi->cluster_size - 1);
1391	}
1392	dir->i_size += nr_cluster << sbi->cluster_bits;
1393	MSDOS_I(inode: dir)->mmu_private += nr_cluster << sbi->cluster_bits;
1394	}
1395	sinfo->slot_off = pos;
1396	sinfo->de = de;
1397	sinfo->bh = bh;
1398	sinfo->i_pos = fat_make_i_pos(sb, bh: sinfo->bh, de: sinfo->de);
1399
1400	return 0;
1401
1402	error:
1403	brelse(bh);
1404	for (i = 0; i < nr_bhs; i++)
1405	brelse(bh: bhs[i]);
1406	return err;
1407
1408	error_remove:
1409	brelse(bh);
1410	if (free_slots)
1411	__fat_remove_entries(dir, pos, nr_slots: free_slots);
1412	return err;
1413	}
1414	EXPORT_SYMBOL_GPL(fat_add_entries);
1415