blob: 92b7363dafa95d6a1a529b31f008eb682ad5d047 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/vfat/namei.c
3 *
4 * Written 1992,1993 by Werner Almesberger
5 *
6 * Windows95/Windows NT compatible extended MSDOS filesystem
7 * by Gordon Chaffee Copyright (C) 1995. Send bug reports for the
8 * VFAT filesystem to <chaffee@cs.berkeley.edu>. Specify
9 * what file operation caused you trouble and if you can duplicate
10 * the problem, send a script that demonstrates it.
11 *
12 * Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
13 *
14 * Support Multibyte characters and cleanup by
15 * OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
16 */
17
18#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/ctype.h>
20#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/namei.h>
OGAWA Hirofumi9e975da2008-11-06 12:53:46 -080022#include "fat.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080024/*
25 * If new entry was created in the parent, it could create the 8.3
26 * alias (the shortname of logname). So, the parent may have the
27 * negative-dentry which matches the created 8.3 alias.
28 *
29 * If it happened, the negative dentry isn't actually negative
30 * anymore. So, drop it.
31 */
32static int vfat_revalidate_shortname(struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033{
34 int ret = 1;
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080035 spin_lock(&dentry->d_lock);
David Howells2b0143b2015-03-17 22:25:59 +000036 if (dentry->d_time != d_inode(dentry->d_parent)->i_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 ret = 0;
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080038 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 return ret;
40}
41
Al Viro0b728e12012-06-10 16:03:43 -040042static int vfat_revalidate(struct dentry *dentry, unsigned int flags)
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080043{
Al Viro0b728e12012-06-10 16:03:43 -040044 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +110045 return -ECHILD;
46
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080047 /* This is not negative dentry. Always valid. */
David Howells2b0143b2015-03-17 22:25:59 +000048 if (d_really_is_positive(dentry))
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080049 return 1;
50 return vfat_revalidate_shortname(dentry);
51}
52
Al Viro0b728e12012-06-10 16:03:43 -040053static int vfat_revalidate_ci(struct dentry *dentry, unsigned int flags)
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080054{
Al Viro0b728e12012-06-10 16:03:43 -040055 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +110056 return -ECHILD;
57
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080058 /*
59 * This is not negative dentry. Always valid.
60 *
61 * Note, rename() to existing directory entry will have ->d_inode,
62 * and will use existing name which isn't specified name by user.
63 *
64 * We may be able to drop this positive dentry here. But dropping
65 * positive dentry isn't good idea. So it's unsupported like
66 * rename("filename", "FILENAME") for now.
67 */
David Howells2b0143b2015-03-17 22:25:59 +000068 if (d_really_is_positive(dentry))
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080069 return 1;
70
71 /*
72 * This may be nfsd (or something), anyway, we can't see the
73 * intent of this. So, since this can be for creation, drop it.
74 */
Al Viro0b728e12012-06-10 16:03:43 -040075 if (!flags)
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080076 return 0;
77
78 /*
79 * Drop the negative dentry, in order to make sure to use the
80 * case sensitive name which is specified by user if this is
81 * for creation.
82 */
Al Viro0b728e12012-06-10 16:03:43 -040083 if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
Al Viro407938e2011-06-25 21:37:18 -040084 return 0;
OGAWA Hirofumi1b524672008-11-06 12:53:51 -080085
86 return vfat_revalidate_shortname(dentry);
87}
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089/* returns the length of a struct qstr, ignoring trailing dots */
Nick Piggin621e1552011-01-07 17:49:27 +110090static unsigned int __vfat_striptail_len(unsigned int len, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Nick Piggin621e1552011-01-07 17:49:27 +110092 while (len && name[len - 1] == '.')
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 len--;
94 return len;
95}
96
Nick Piggin621e1552011-01-07 17:49:27 +110097static unsigned int vfat_striptail_len(const struct qstr *qstr)
98{
99 return __vfat_striptail_len(qstr->len, qstr->name);
100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102/*
103 * Compute the hash for the vfat name corresponding to the dentry.
104 * Note: if the name is invalid, we leave the hash code unchanged so
105 * that the existing dentry can be used. The vfat fs routines will
106 * return ENOENT or EINVAL as appropriate.
107 */
Linus Torvaldsda53be12013-05-21 15:22:44 -0700108static int vfat_hash(const struct dentry *dentry, struct qstr *qstr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Linus Torvalds8387ff22016-06-10 07:51:30 -0700110 qstr->hash = full_name_hash(dentry, qstr->name, vfat_striptail_len(qstr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 return 0;
112}
113
114/*
115 * Compute the hash for the vfat name corresponding to the dentry.
116 * Note: if the name is invalid, we leave the hash code unchanged so
117 * that the existing dentry can be used. The vfat fs routines will
118 * return ENOENT or EINVAL as appropriate.
119 */
Linus Torvaldsda53be12013-05-21 15:22:44 -0700120static int vfat_hashi(const struct dentry *dentry, struct qstr *qstr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
Nick Pigginb1e6a012011-01-07 17:49:28 +1100122 struct nls_table *t = MSDOS_SB(dentry->d_sb)->nls_io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 const unsigned char *name;
124 unsigned int len;
125 unsigned long hash;
126
127 name = qstr->name;
128 len = vfat_striptail_len(qstr);
129
Linus Torvalds8387ff22016-06-10 07:51:30 -0700130 hash = init_name_hash(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 while (len--)
132 hash = partial_name_hash(nls_tolower(t, *name++), hash);
133 qstr->hash = end_name_hash(hash);
134
135 return 0;
136}
137
138/*
139 * Case insensitive compare of two vfat names.
140 */
Al Viro6fa67e72016-07-31 16:37:25 -0400141static int vfat_cmpi(const struct dentry *dentry,
Nick Piggin621e1552011-01-07 17:49:27 +1100142 unsigned int len, const char *str, const struct qstr *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143{
Al Virod3fe1982016-07-29 18:23:59 -0400144 struct nls_table *t = MSDOS_SB(dentry->d_sb)->nls_io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 unsigned int alen, blen;
146
147 /* A filename cannot end in '.' or we treat it like it has none */
Nick Piggin621e1552011-01-07 17:49:27 +1100148 alen = vfat_striptail_len(name);
149 blen = __vfat_striptail_len(len, str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (alen == blen) {
Nick Piggin621e1552011-01-07 17:49:27 +1100151 if (nls_strnicmp(t, name->name, str, alen) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 return 0;
153 }
154 return 1;
155}
156
157/*
158 * Case sensitive compare of two vfat names.
159 */
Al Viro6fa67e72016-07-31 16:37:25 -0400160static int vfat_cmp(const struct dentry *dentry,
Nick Piggin621e1552011-01-07 17:49:27 +1100161 unsigned int len, const char *str, const struct qstr *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
163 unsigned int alen, blen;
164
165 /* A filename cannot end in '.' or we treat it like it has none */
Nick Piggin621e1552011-01-07 17:49:27 +1100166 alen = vfat_striptail_len(name);
167 blen = __vfat_striptail_len(len, str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 if (alen == blen) {
Nick Piggin621e1552011-01-07 17:49:27 +1100169 if (strncmp(name->name, str, alen) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 return 0;
171 }
172 return 1;
173}
174
Al Viroce6cdc42009-02-20 05:59:46 +0000175static const struct dentry_operations vfat_ci_dentry_ops = {
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800176 .d_revalidate = vfat_revalidate_ci,
177 .d_hash = vfat_hashi,
178 .d_compare = vfat_cmpi,
179};
180
Al Viroce6cdc42009-02-20 05:59:46 +0000181static const struct dentry_operations vfat_dentry_ops = {
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800182 .d_revalidate = vfat_revalidate,
183 .d_hash = vfat_hash,
184 .d_compare = vfat_cmp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185};
186
187/* Characters that are undesirable in an MS-DOS file name */
188
189static inline wchar_t vfat_bad_char(wchar_t w)
190{
191 return (w < 0x0020)
192 || (w == '*') || (w == '?') || (w == '<') || (w == '>')
193 || (w == '|') || (w == '"') || (w == ':') || (w == '/')
194 || (w == '\\');
195}
196
197static inline wchar_t vfat_replace_char(wchar_t w)
198{
199 return (w == '[') || (w == ']') || (w == ';') || (w == ',')
200 || (w == '+') || (w == '=');
201}
202
203static wchar_t vfat_skip_char(wchar_t w)
204{
205 return (w == '.') || (w == ' ');
206}
207
208static inline int vfat_is_used_badchars(const wchar_t *s, int len)
209{
210 int i;
211
212 for (i = 0; i < len; i++)
213 if (vfat_bad_char(s[i]))
214 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Keith Mokf22032b2008-04-28 02:16:29 -0700216 if (s[i - 1] == ' ') /* last character cannot be space */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return -EINVAL;
Keith Mokf22032b2008-04-28 02:16:29 -0700218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 return 0;
220}
221
222static int vfat_find_form(struct inode *dir, unsigned char *name)
223{
224 struct fat_slot_info sinfo;
225 int err = fat_scan(dir, name, &sinfo);
226 if (err)
227 return -ENOENT;
228 brelse(sinfo.bh);
229 return 0;
230}
231
232/*
233 * 1) Valid characters for the 8.3 format alias are any combination of
234 * letters, uppercase alphabets, digits, any of the
235 * following special characters:
236 * $ % ' ` - @ { } ~ ! # ( ) & _ ^
237 * In this case Longfilename is not stored in disk.
238 *
239 * WinNT's Extension:
240 * File name and extension name is contain uppercase/lowercase
241 * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
242 *
243 * 2) File name is 8.3 format, but it contain the uppercase and
244 * lowercase char, muliti bytes char, etc. In this case numtail is not
245 * added, but Longfilename is stored.
246 *
247 * 3) When the one except for the above, or the following special
248 * character are contained:
249 * . [ ] ; , + =
250 * numtail is added, and Longfilename must be stored in disk .
251 */
252struct shortname_info {
253 unsigned char lower:1,
254 upper:1,
255 valid:1;
256};
257#define INIT_SHORTNAME_INFO(x) do { \
258 (x)->lower = 1; \
259 (x)->upper = 1; \
260 (x)->valid = 1; \
261} while (0)
262
263static inline int to_shortname_char(struct nls_table *nls,
264 unsigned char *buf, int buf_size,
265 wchar_t *src, struct shortname_info *info)
266{
267 int len;
268
269 if (vfat_skip_char(*src)) {
270 info->valid = 0;
271 return 0;
272 }
273 if (vfat_replace_char(*src)) {
274 info->valid = 0;
275 buf[0] = '_';
276 return 1;
277 }
278
279 len = nls->uni2char(*src, buf, buf_size);
280 if (len <= 0) {
281 info->valid = 0;
282 buf[0] = '_';
283 len = 1;
284 } else if (len == 1) {
285 unsigned char prev = buf[0];
286
287 if (buf[0] >= 0x7F) {
288 info->lower = 0;
289 info->upper = 0;
290 }
291
292 buf[0] = nls_toupper(nls, buf[0]);
293 if (isalpha(buf[0])) {
294 if (buf[0] == prev)
295 info->lower = 0;
296 else
297 info->upper = 0;
298 }
299 } else {
300 info->lower = 0;
301 info->upper = 0;
302 }
303
304 return len;
305}
306
307/*
308 * Given a valid longname, create a unique shortname. Make sure the
309 * shortname does not exist
310 * Returns negative number on error, 0 for a normal
311 * return, and 1 for valid shortname
312 */
313static int vfat_create_shortname(struct inode *dir, struct nls_table *nls,
314 wchar_t *uname, int ulen,
315 unsigned char *name_res, unsigned char *lcase)
316{
317 struct fat_mount_options *opts = &MSDOS_SB(dir->i_sb)->options;
318 wchar_t *ip, *ext_start, *end, *name_start;
Nikolaus Schulz30d18722010-04-01 02:21:10 +0900319 unsigned char base[9], ext[4], buf[5], *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 unsigned char charbuf[NLS_MAX_CHARSET_SIZE];
321 int chl, chi;
322 int sz = 0, extlen, baselen, i, numtail_baselen, numtail2_baselen;
323 int is_shortname;
324 struct shortname_info base_info, ext_info;
325
326 is_shortname = 1;
327 INIT_SHORTNAME_INFO(&base_info);
328 INIT_SHORTNAME_INFO(&ext_info);
329
330 /* Now, we need to create a shortname from the long name */
331 ext_start = end = &uname[ulen];
332 while (--ext_start >= uname) {
333 if (*ext_start == 0x002E) { /* is `.' */
334 if (ext_start == end - 1) {
335 sz = ulen;
336 ext_start = NULL;
337 }
338 break;
339 }
340 }
341
342 if (ext_start == uname - 1) {
343 sz = ulen;
344 ext_start = NULL;
345 } else if (ext_start) {
346 /*
347 * Names which start with a dot could be just
348 * an extension eg. "...test". In this case Win95
349 * uses the extension as the name and sets no extension.
350 */
351 name_start = &uname[0];
352 while (name_start < ext_start) {
353 if (!vfat_skip_char(*name_start))
354 break;
355 name_start++;
356 }
357 if (name_start != ext_start) {
358 sz = ext_start - uname;
359 ext_start++;
360 } else {
361 sz = ulen;
362 ext_start = NULL;
363 }
364 }
365
366 numtail_baselen = 6;
367 numtail2_baselen = 2;
368 for (baselen = i = 0, p = base, ip = uname; i < sz; i++, ip++) {
369 chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
370 ip, &base_info);
371 if (chl == 0)
372 continue;
373
374 if (baselen < 2 && (baselen + chl) > 2)
375 numtail2_baselen = baselen;
376 if (baselen < 6 && (baselen + chl) > 6)
377 numtail_baselen = baselen;
378 for (chi = 0; chi < chl; chi++) {
379 *p++ = charbuf[chi];
380 baselen++;
381 if (baselen >= 8)
382 break;
383 }
384 if (baselen >= 8) {
385 if ((chi < chl - 1) || (ip + 1) - uname < sz)
386 is_shortname = 0;
387 break;
388 }
389 }
390 if (baselen == 0) {
391 return -EINVAL;
392 }
393
394 extlen = 0;
395 if (ext_start) {
396 for (p = ext, ip = ext_start; extlen < 3 && ip < end; ip++) {
397 chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
398 ip, &ext_info);
399 if (chl == 0)
400 continue;
401
402 if ((extlen + chl) > 3) {
403 is_shortname = 0;
404 break;
405 }
406 for (chi = 0; chi < chl; chi++) {
407 *p++ = charbuf[chi];
408 extlen++;
409 }
410 if (extlen >= 3) {
411 if (ip + 1 != end)
412 is_shortname = 0;
413 break;
414 }
415 }
416 }
417 ext[extlen] = '\0';
418 base[baselen] = '\0';
419
420 /* Yes, it can happen. ".\xe5" would do it. */
421 if (base[0] == DELETED_FLAG)
422 base[0] = 0x05;
423
424 /* OK, at this point we know that base is not longer than 8 symbols,
425 * ext is not longer than 3, base is nonempty, both don't contain
426 * any bad symbols (lowercase transformed to uppercase).
427 */
428
429 memset(name_res, ' ', MSDOS_NAME);
430 memcpy(name_res, base, baselen);
431 memcpy(name_res + 8, ext, extlen);
432 *lcase = 0;
433 if (is_shortname && base_info.valid && ext_info.valid) {
434 if (vfat_find_form(dir, name_res) == 0)
435 return -EEXIST;
436
437 if (opts->shortname & VFAT_SFN_CREATE_WIN95) {
438 return (base_info.upper && ext_info.upper);
439 } else if (opts->shortname & VFAT_SFN_CREATE_WINNT) {
440 if ((base_info.upper || base_info.lower) &&
441 (ext_info.upper || ext_info.lower)) {
442 if (!base_info.upper && base_info.lower)
443 *lcase |= CASE_LOWER_BASE;
444 if (!ext_info.upper && ext_info.lower)
445 *lcase |= CASE_LOWER_EXT;
446 return 1;
447 }
448 return 0;
449 } else {
450 BUG();
451 }
452 }
453
454 if (opts->numtail == 0)
455 if (vfat_find_form(dir, name_res) < 0)
456 return 0;
457
458 /*
459 * Try to find a unique extension. This used to
460 * iterate through all possibilities sequentially,
461 * but that gave extremely bad performance. Windows
462 * only tries a few cases before using random
463 * values for part of the base.
464 */
465
466 if (baselen > 6) {
467 baselen = numtail_baselen;
468 name_res[7] = ' ';
469 }
470 name_res[baselen] = '~';
471 for (i = 1; i < 10; i++) {
472 name_res[baselen + 1] = i + '0';
473 if (vfat_find_form(dir, name_res) < 0)
474 return 0;
475 }
476
Nikolaus Schulz30d18722010-04-01 02:21:10 +0900477 i = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 sz = (jiffies >> 16) & 0x7;
479 if (baselen > 2) {
480 baselen = numtail2_baselen;
481 name_res[7] = ' ';
482 }
483 name_res[baselen + 4] = '~';
484 name_res[baselen + 5] = '1' + sz;
485 while (1) {
Nikolaus Schulz30d18722010-04-01 02:21:10 +0900486 snprintf(buf, sizeof(buf), "%04X", i & 0xffff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 memcpy(&name_res[baselen], buf, 4);
488 if (vfat_find_form(dir, name_res) < 0)
489 break;
490 i -= 11;
491 }
492 return 0;
493}
494
495/* Translate a string, including coded sequences into Unicode */
496static int
497xlate_to_uni(const unsigned char *name, int len, unsigned char *outname,
498 int *longlen, int *outlen, int escape, int utf8,
499 struct nls_table *nls)
500{
501 const unsigned char *ip;
502 unsigned char nc;
503 unsigned char *op;
504 unsigned int ec;
505 int i, k, fill;
506 int charlen;
507
508 if (utf8) {
Alan Stern0720a062011-11-17 16:42:19 -0500509 *outlen = utf8s_to_utf16s(name, len, UTF16_HOST_ENDIAN,
510 (wchar_t *) outname, FAT_LFN_LEN + 2);
OGAWA Hirofumi67638e42009-08-01 21:30:31 +0900511 if (*outlen < 0)
512 return *outlen;
Kevin Dankwardteeb5b4a2010-02-10 23:43:40 +0900513 else if (*outlen > FAT_LFN_LEN)
Keith Mokf22032b2008-04-28 02:16:29 -0700514 return -ENAMETOOLONG;
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 op = &outname[*outlen * sizeof(wchar_t)];
517 } else {
Namjae Jeon41f0c022012-03-23 15:02:38 -0700518 for (i = 0, ip = name, op = outname, *outlen = 0;
Namjae Jeond533df02012-03-23 15:02:39 -0700519 i < len && *outlen < FAT_LFN_LEN;
Namjae Jeon41f0c022012-03-23 15:02:38 -0700520 *outlen += 1) {
521 if (escape && (*ip == ':')) {
522 if (i > len - 5)
523 return -EINVAL;
524 ec = 0;
525 for (k = 1; k < 5; k++) {
526 nc = ip[k];
527 ec <<= 4;
528 if (nc >= '0' && nc <= '9') {
529 ec |= nc - '0';
530 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
Namjae Jeon41f0c022012-03-23 15:02:38 -0700532 if (nc >= 'a' && nc <= 'f') {
533 ec |= nc - ('a' - 10);
534 continue;
535 }
536 if (nc >= 'A' && nc <= 'F') {
537 ec |= nc - ('A' - 10);
538 continue;
539 }
540 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 }
Namjae Jeon41f0c022012-03-23 15:02:38 -0700542 *op++ = ec & 0xFF;
543 *op++ = ec >> 8;
544 ip += 5;
545 i += 5;
546 } else {
547 charlen = nls->char2uni(ip, len - i,
548 (wchar_t *)op);
549 if (charlen < 0)
550 return -EINVAL;
551 ip += charlen;
552 i += charlen;
553 op += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
Namjae Jeon41f0c022012-03-23 15:02:38 -0700556 if (i < len)
557 return -ENAMETOOLONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560 *longlen = *outlen;
561 if (*outlen % 13) {
562 *op++ = 0;
563 *op++ = 0;
564 *outlen += 1;
565 if (*outlen % 13) {
566 fill = 13 - (*outlen % 13);
567 for (i = 0; i < fill; i++) {
568 *op++ = 0xff;
569 *op++ = 0xff;
570 }
571 *outlen += fill;
572 }
573 }
574
575 return 0;
576}
577
578static int vfat_build_slots(struct inode *dir, const unsigned char *name,
579 int len, int is_dir, int cluster,
580 struct timespec *ts,
581 struct msdos_dir_slot *slots, int *nr_slots)
582{
583 struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb);
584 struct fat_mount_options *opts = &sbi->options;
585 struct msdos_dir_slot *ps;
586 struct msdos_dir_entry *de;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 unsigned char cksum, lcase;
588 unsigned char msdos_name[MSDOS_NAME];
589 wchar_t *uname;
590 __le16 time, date;
OGAWA Hirofumi7decd1c2008-11-06 12:53:47 -0800591 u8 time_cs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 int err, ulen, usize, i;
593 loff_t offset;
594
595 *nr_slots = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
OGAWA Hirofumic7a6c4e2008-04-28 02:16:29 -0700597 uname = __getname();
598 if (!uname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 return -ENOMEM;
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 err = xlate_to_uni(name, len, (unsigned char *)uname, &ulen, &usize,
602 opts->unicode_xlate, opts->utf8, sbi->nls_io);
603 if (err)
604 goto out_free;
605
606 err = vfat_is_used_badchars(uname, ulen);
607 if (err)
608 goto out_free;
609
610 err = vfat_create_shortname(dir, sbi->nls_disk, uname, ulen,
611 msdos_name, &lcase);
612 if (err < 0)
613 goto out_free;
614 else if (err == 1) {
615 de = (struct msdos_dir_entry *)slots;
616 err = 0;
617 goto shortname;
618 }
619
620 /* build the entry of long file name */
OGAWA Hirofumi451cbaa2005-10-30 15:03:49 -0800621 cksum = fat_checksum(msdos_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 *nr_slots = usize / 13;
624 for (ps = slots, i = *nr_slots; i > 0; i--, ps++) {
625 ps->id = i;
626 ps->attr = ATTR_EXT;
627 ps->reserved = 0;
628 ps->alias_checksum = cksum;
629 ps->start = 0;
630 offset = (i - 1) * 13;
631 fatwchar_to16(ps->name0_4, uname + offset, 5);
632 fatwchar_to16(ps->name5_10, uname + offset + 5, 6);
633 fatwchar_to16(ps->name11_12, uname + offset + 11, 2);
634 }
635 slots[0].id |= 0x40;
636 de = (struct msdos_dir_entry *)ps;
637
638shortname:
639 /* build the entry of 8.3 alias name */
640 (*nr_slots)++;
641 memcpy(de->name, msdos_name, MSDOS_NAME);
642 de->attr = is_dir ? ATTR_DIR : ATTR_ARCH;
643 de->lcase = lcase;
OGAWA Hirofumi7decd1c2008-11-06 12:53:47 -0800644 fat_time_unix2fat(sbi, ts, &time, &date, &time_cs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 de->time = de->ctime = time;
646 de->date = de->cdate = de->adate = date;
OGAWA Hirofumi7decd1c2008-11-06 12:53:47 -0800647 de->ctime_cs = time_cs;
Steven J. Magnania943ed72012-07-30 14:42:13 -0700648 fat_set_start(de, cluster);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 de->size = 0;
650out_free:
OGAWA Hirofumic7a6c4e2008-04-28 02:16:29 -0700651 __putname(uname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 return err;
653}
654
Al Virob59091c2016-07-20 22:43:14 -0400655static int vfat_add_entry(struct inode *dir, const struct qstr *qname,
656 int is_dir, int cluster, struct timespec *ts,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 struct fat_slot_info *sinfo)
658{
659 struct msdos_dir_slot *slots;
660 unsigned int len;
661 int err, nr_slots;
662
663 len = vfat_striptail_len(qname);
664 if (len == 0)
665 return -ENOENT;
666
Linus Torvalds8f593422008-05-19 19:53:01 -0700667 slots = kmalloc(sizeof(*slots) * MSDOS_SLOTS, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 if (slots == NULL)
669 return -ENOMEM;
670
671 err = vfat_build_slots(dir, qname->name, len, is_dir, cluster, ts,
672 slots, &nr_slots);
673 if (err)
674 goto cleanup;
675
676 err = fat_add_entries(dir, slots, nr_slots, sinfo);
677 if (err)
678 goto cleanup;
679
680 /* update timestamp */
681 dir->i_ctime = dir->i_mtime = dir->i_atime = *ts;
682 if (IS_DIRSYNC(dir))
683 (void)fat_sync_inode(dir);
684 else
685 mark_inode_dirty(dir);
686cleanup:
687 kfree(slots);
688 return err;
689}
690
Al Virob59091c2016-07-20 22:43:14 -0400691static int vfat_find(struct inode *dir, const struct qstr *qname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 struct fat_slot_info *sinfo)
693{
694 unsigned int len = vfat_striptail_len(qname);
695 if (len == 0)
696 return -ENOENT;
697 return fat_search_long(dir, qname->name, len, sinfo);
698}
699
OGAWA Hirofumi8045e292010-01-12 03:32:24 +0900700/*
701 * (nfsd's) anonymous disconnected dentry?
702 * NOTE: !IS_ROOT() is not anonymous (I.e. d_splice_alias() did the job).
703 */
704static int vfat_d_anon_disconn(struct dentry *dentry)
705{
706 return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
707}
708
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400710 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
712 struct super_block *sb = dir->i_sb;
713 struct fat_slot_info sinfo;
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800714 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 struct dentry *alias;
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800716 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Marco Stornellie40b34c2012-10-06 12:40:03 +0200718 mutex_lock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 err = vfat_find(dir, &dentry->d_name, &sinfo);
721 if (err) {
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800722 if (err == -ENOENT) {
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800723 inode = NULL;
724 goto out;
725 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 goto error;
727 }
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800728
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
730 brelse(sinfo.bh);
731 if (IS_ERR(inode)) {
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800732 err = PTR_ERR(inode);
733 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 }
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 alias = d_find_alias(inode);
Al Viro1ead0e72014-12-02 15:59:37 -0800737 /*
738 * Checking "alias->d_parent == dentry->d_parent" to make sure
739 * FS is not corrupted (especially double linked dir).
740 */
741 if (alias && alias->d_parent == dentry->d_parent &&
742 !vfat_d_anon_disconn(alias)) {
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800743 /*
OGAWA Hirofumi8045e292010-01-12 03:32:24 +0900744 * This inode has non anonymous-DCACHE_DISCONNECTED
745 * dentry. This means, the user did ->lookup() by an
746 * another name (longname vs 8.3 alias of it) in past.
OGAWA Hirofumi1b524672008-11-06 12:53:51 -0800747 *
748 * Switch to new one for reason of locality if possible.
749 */
OGAWA Hirofumi1c13a242008-11-06 12:53:52 -0800750 BUG_ON(d_unhashed(alias));
751 if (!S_ISDIR(inode->i_mode))
752 d_move(alias, dentry);
753 iput(inode);
Marco Stornellie40b34c2012-10-06 12:40:03 +0200754 mutex_unlock(&MSDOS_SB(sb)->s_lock);
OGAWA Hirofumi1c13a242008-11-06 12:53:52 -0800755 return alias;
OGAWA Hirofumi8045e292010-01-12 03:32:24 +0900756 } else
757 dput(alias);
758
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800759out:
Marco Stornellie40b34c2012-10-06 12:40:03 +0200760 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Al Viro1ead0e72014-12-02 15:59:37 -0800761 if (!inode)
762 dentry->d_time = dir->i_version;
763 return d_splice_alias(inode, dentry);
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800764error:
Marco Stornellie40b34c2012-10-06 12:40:03 +0200765 mutex_unlock(&MSDOS_SB(sb)->s_lock);
OGAWA Hirofumi068f5ae2008-11-06 12:53:51 -0800766 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767}
768
Al Viro4acdaf22011-07-26 01:42:34 -0400769static int vfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400770 bool excl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771{
772 struct super_block *sb = dir->i_sb;
773 struct inode *inode;
774 struct fat_slot_info sinfo;
775 struct timespec ts;
776 int err;
777
Marco Stornellie40b34c2012-10-06 12:40:03 +0200778 mutex_lock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 ts = CURRENT_TIME_SEC;
781 err = vfat_add_entry(dir, &dentry->d_name, 0, 0, &ts, &sinfo);
782 if (err)
783 goto out;
784 dir->i_version++;
785
786 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
787 brelse(sinfo.bh);
788 if (IS_ERR(inode)) {
789 err = PTR_ERR(inode);
790 goto out;
791 }
792 inode->i_version++;
793 inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
794 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
795
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 d_instantiate(dentry, inode);
797out:
Marco Stornellie40b34c2012-10-06 12:40:03 +0200798 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 return err;
800}
801
802static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
803{
David Howells2b0143b2015-03-17 22:25:59 +0000804 struct inode *inode = d_inode(dentry);
Linus Torvalds8f593422008-05-19 19:53:01 -0700805 struct super_block *sb = dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 struct fat_slot_info sinfo;
807 int err;
808
Marco Stornellie40b34c2012-10-06 12:40:03 +0200809 mutex_lock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
811 err = fat_dir_empty(inode);
812 if (err)
813 goto out;
814 err = vfat_find(dir, &dentry->d_name, &sinfo);
815 if (err)
816 goto out;
817
818 err = fat_remove_entries(dir, &sinfo); /* and releases bh */
819 if (err)
820 goto out;
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700821 drop_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
Dave Hansence71ec32006-09-30 23:29:06 -0700823 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
825 fat_detach(inode);
Al Viro1ead0e72014-12-02 15:59:37 -0800826 dentry->d_time = dir->i_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827out:
Marco Stornellie40b34c2012-10-06 12:40:03 +0200828 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 return err;
831}
832
833static int vfat_unlink(struct inode *dir, struct dentry *dentry)
834{
David Howells2b0143b2015-03-17 22:25:59 +0000835 struct inode *inode = d_inode(dentry);
Linus Torvalds8f593422008-05-19 19:53:01 -0700836 struct super_block *sb = dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 struct fat_slot_info sinfo;
838 int err;
839
Marco Stornellie40b34c2012-10-06 12:40:03 +0200840 mutex_lock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
842 err = vfat_find(dir, &dentry->d_name, &sinfo);
843 if (err)
844 goto out;
845
846 err = fat_remove_entries(dir, &sinfo); /* and releases bh */
847 if (err)
848 goto out;
Dave Hansence71ec32006-09-30 23:29:06 -0700849 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
851 fat_detach(inode);
Al Viro1ead0e72014-12-02 15:59:37 -0800852 dentry->d_time = dir->i_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853out:
Marco Stornellie40b34c2012-10-06 12:40:03 +0200854 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
856 return err;
857}
858
Al Viro18bb1db2011-07-26 01:41:39 -0400859static int vfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
861 struct super_block *sb = dir->i_sb;
862 struct inode *inode;
863 struct fat_slot_info sinfo;
864 struct timespec ts;
865 int err, cluster;
866
Marco Stornellie40b34c2012-10-06 12:40:03 +0200867 mutex_lock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
869 ts = CURRENT_TIME_SEC;
870 cluster = fat_alloc_new_dir(dir, &ts);
871 if (cluster < 0) {
872 err = cluster;
873 goto out;
874 }
875 err = vfat_add_entry(dir, &dentry->d_name, 1, cluster, &ts, &sinfo);
876 if (err)
877 goto out_free;
878 dir->i_version++;
Dave Hansend8c76e62006-09-30 23:29:04 -0700879 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
881 inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
882 brelse(sinfo.bh);
883 if (IS_ERR(inode)) {
884 err = PTR_ERR(inode);
885 /* the directory was completed, just return a error */
886 goto out;
887 }
888 inode->i_version++;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200889 set_nlink(inode, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
891 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
892
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 d_instantiate(dentry, inode);
894
Marco Stornellie40b34c2012-10-06 12:40:03 +0200895 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 return 0;
897
898out_free:
899 fat_free_clusters(dir, cluster);
900out:
Marco Stornellie40b34c2012-10-06 12:40:03 +0200901 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 return err;
903}
904
905static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
906 struct inode *new_dir, struct dentry *new_dentry)
907{
908 struct buffer_head *dotdot_bh;
909 struct msdos_dir_entry *dotdot_de;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 struct inode *old_inode, *new_inode;
911 struct fat_slot_info old_sinfo, sinfo;
912 struct timespec ts;
Steven J. Magnani7669e8f2012-10-04 17:14:45 -0700913 loff_t new_i_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 int err, is_dir, update_dotdot, corrupt = 0;
Linus Torvalds8f593422008-05-19 19:53:01 -0700915 struct super_block *sb = old_dir->i_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916
917 old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
David Howells2b0143b2015-03-17 22:25:59 +0000918 old_inode = d_inode(old_dentry);
919 new_inode = d_inode(new_dentry);
Marco Stornellie40b34c2012-10-06 12:40:03 +0200920 mutex_lock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
922 if (err)
923 goto out;
924
925 is_dir = S_ISDIR(old_inode->i_mode);
926 update_dotdot = (is_dir && old_dir != new_dir);
927 if (update_dotdot) {
Steven J. Magnani7669e8f2012-10-04 17:14:45 -0700928 if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 err = -EIO;
930 goto out;
931 }
932 }
933
934 ts = CURRENT_TIME_SEC;
935 if (new_inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 if (is_dir) {
937 err = fat_dir_empty(new_inode);
938 if (err)
939 goto out;
940 }
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800941 new_i_pos = MSDOS_I(new_inode)->i_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 fat_detach(new_inode);
943 } else {
944 err = vfat_add_entry(new_dir, &new_dentry->d_name, is_dir, 0,
945 &ts, &sinfo);
946 if (err)
947 goto out;
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800948 new_i_pos = sinfo.i_pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 }
950 new_dir->i_version++;
951
952 fat_detach(old_inode);
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -0800953 fat_attach(old_inode, new_i_pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 if (IS_DIRSYNC(new_dir)) {
955 err = fat_sync_inode(old_inode);
956 if (err)
957 goto error_inode;
958 } else
959 mark_inode_dirty(old_inode);
960
961 if (update_dotdot) {
Steven J. Magnania943ed72012-07-30 14:42:13 -0700962 fat_set_start(dotdot_de, MSDOS_I(new_dir)->i_logstart);
Al Virob5224122009-06-07 13:44:36 -0400963 mark_buffer_dirty_inode(dotdot_bh, old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (IS_DIRSYNC(new_dir)) {
965 err = sync_dirty_buffer(dotdot_bh);
966 if (err)
967 goto error_dotdot;
968 }
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700969 drop_nlink(old_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 if (!new_inode)
Dave Hansend8c76e62006-09-30 23:29:04 -0700971 inc_nlink(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 }
973
974 err = fat_remove_entries(old_dir, &old_sinfo); /* and releases bh */
975 old_sinfo.bh = NULL;
976 if (err)
977 goto error_dotdot;
978 old_dir->i_version++;
979 old_dir->i_ctime = old_dir->i_mtime = ts;
980 if (IS_DIRSYNC(old_dir))
981 (void)fat_sync_inode(old_dir);
982 else
983 mark_inode_dirty(old_dir);
984
985 if (new_inode) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700986 drop_nlink(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 if (is_dir)
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700988 drop_nlink(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 new_inode->i_ctime = ts;
990 }
991out:
992 brelse(sinfo.bh);
993 brelse(dotdot_bh);
994 brelse(old_sinfo.bh);
Marco Stornellie40b34c2012-10-06 12:40:03 +0200995 mutex_unlock(&MSDOS_SB(sb)->s_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
997 return err;
998
999error_dotdot:
1000 /* data cluster is shared, serious corruption */
1001 corrupt = 1;
1002
1003 if (update_dotdot) {
Steven J. Magnania943ed72012-07-30 14:42:13 -07001004 fat_set_start(dotdot_de, MSDOS_I(old_dir)->i_logstart);
Al Virob5224122009-06-07 13:44:36 -04001005 mark_buffer_dirty_inode(dotdot_bh, old_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 corrupt |= sync_dirty_buffer(dotdot_bh);
1007 }
1008error_inode:
1009 fat_detach(old_inode);
1010 fat_attach(old_inode, old_sinfo.i_pos);
1011 if (new_inode) {
OGAWA Hirofumi9131dd42005-10-30 15:03:50 -08001012 fat_attach(new_inode, new_i_pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 if (corrupt)
1014 corrupt |= fat_sync_inode(new_inode);
1015 } else {
1016 /*
1017 * If new entry was not sharing the data cluster, it
1018 * shouldn't be serious corruption.
1019 */
1020 int err2 = fat_remove_entries(new_dir, &sinfo);
1021 if (corrupt)
1022 corrupt |= err2;
1023 sinfo.bh = NULL;
1024 }
1025 if (corrupt < 0) {
Denis Karpov85c78592009-06-04 02:34:22 +09001026 fat_fs_error(new_dir->i_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 "%s: Filesystem corrupted (i_pos %lld)",
Harvey Harrison8e24eea2008-04-30 00:55:09 -07001028 __func__, sinfo.i_pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030 goto out;
1031}
1032
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001033static const struct inode_operations vfat_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 .create = vfat_create,
1035 .lookup = vfat_lookup,
1036 .unlink = vfat_unlink,
1037 .mkdir = vfat_mkdir,
1038 .rmdir = vfat_rmdir,
1039 .rename = vfat_rename,
OGAWA Hirofumi1278fdd2008-04-28 02:16:25 -07001040 .setattr = fat_setattr,
OGAWA Hirofumida63fc72006-11-16 01:19:28 -08001041 .getattr = fat_getattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042};
1043
Al Viro3d239852010-12-18 10:44:00 -05001044static void setup(struct super_block *sb)
1045{
OGAWA Hirofumi384f5c92011-04-12 21:08:37 +09001046 MSDOS_SB(sb)->dir_ops = &vfat_dir_inode_operations;
Al Viro3d239852010-12-18 10:44:00 -05001047 if (MSDOS_SB(sb)->options.name_check != 's')
1048 sb->s_d_op = &vfat_ci_dentry_ops;
1049 else
1050 sb->s_d_op = &vfat_dentry_ops;
1051}
1052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053static int vfat_fill_super(struct super_block *sb, void *data, int silent)
1054{
OGAWA Hirofumi384f5c92011-04-12 21:08:37 +09001055 return fat_fill_super(sb, data, silent, 1, setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056}
1057
Al Viro152a0832010-07-25 00:46:55 +04001058static struct dentry *vfat_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -07001059 int flags, const char *dev_name,
Al Viro152a0832010-07-25 00:46:55 +04001060 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
Al Viro152a0832010-07-25 00:46:55 +04001062 return mount_bdev(fs_type, flags, dev_name, data, vfat_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063}
1064
1065static struct file_system_type vfat_fs_type = {
1066 .owner = THIS_MODULE,
1067 .name = "vfat",
Al Viro152a0832010-07-25 00:46:55 +04001068 .mount = vfat_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 .kill_sb = kill_block_super,
1070 .fs_flags = FS_REQUIRES_DEV,
1071};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08001072MODULE_ALIAS_FS("vfat");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
1074static int __init init_vfat_fs(void)
1075{
1076 return register_filesystem(&vfat_fs_type);
1077}
1078
1079static void __exit exit_vfat_fs(void)
1080{
1081 unregister_filesystem(&vfat_fs_type);
1082}
1083
1084MODULE_LICENSE("GPL");
1085MODULE_DESCRIPTION("VFAT filesystem support");
1086MODULE_AUTHOR("Gordon Chaffee");
1087
1088module_init(init_vfat_fs)
1089module_exit(exit_vfat_fs)