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