~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ntfs3/dir.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  *
  4  * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
  5  *
  6  *  Directory handling functions for NTFS-based filesystems.
  7  *
  8  */
  9 
 10 #include <linux/fs.h>
 11 #include <linux/nls.h>
 12 
 13 #include "debug.h"
 14 #include "ntfs.h"
 15 #include "ntfs_fs.h"
 16 
 17 /* Convert little endian UTF-16 to NLS string. */
 18 int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const __le16 *name, u32 len,
 19                       u8 *buf, int buf_len)
 20 {
 21         int ret, warn;
 22         u8 *op;
 23         struct nls_table *nls = sbi->options->nls;
 24 
 25         static_assert(sizeof(wchar_t) == sizeof(__le16));
 26 
 27         if (!nls) {
 28                 /* UTF-16 -> UTF-8 */
 29                 ret = utf16s_to_utf8s(name, len, UTF16_LITTLE_ENDIAN, buf,
 30                                       buf_len);
 31                 buf[ret] = '\0';
 32                 return ret;
 33         }
 34 
 35         op = buf;
 36         warn = 0;
 37 
 38         while (len--) {
 39                 u16 ec;
 40                 int charlen;
 41                 char dump[5];
 42 
 43                 if (buf_len < NLS_MAX_CHARSET_SIZE) {
 44                         ntfs_warn(sbi->sb,
 45                                   "filename was truncated while converting.");
 46                         break;
 47                 }
 48 
 49                 ec = le16_to_cpu(*name++);
 50                 charlen = nls->uni2char(ec, op, buf_len);
 51 
 52                 if (charlen > 0) {
 53                         op += charlen;
 54                         buf_len -= charlen;
 55                         continue;
 56                 }
 57 
 58                 *op++ = '_';
 59                 buf_len -= 1;
 60                 if (warn)
 61                         continue;
 62 
 63                 warn = 1;
 64                 hex_byte_pack(&dump[0], ec >> 8);
 65                 hex_byte_pack(&dump[2], ec);
 66                 dump[4] = 0;
 67 
 68                 ntfs_err(sbi->sb, "failed to convert \"%s\" to %s", dump,
 69                          nls->charset);
 70         }
 71 
 72         *op = '\0';
 73         return op - buf;
 74 }
 75 
 76 // clang-format off
 77 #define PLANE_SIZE      0x00010000
 78 
 79 #define SURROGATE_PAIR  0x0000d800
 80 #define SURROGATE_LOW   0x00000400
 81 #define SURROGATE_BITS  0x000003ff
 82 // clang-format on
 83 
 84 /*
 85  * put_utf16 - Modified version of put_utf16 from fs/nls/nls_base.c
 86  *
 87  * Function is sparse warnings free.
 88  */
 89 static inline void put_utf16(wchar_t *s, unsigned int c,
 90                              enum utf16_endian endian)
 91 {
 92         static_assert(sizeof(wchar_t) == sizeof(__le16));
 93         static_assert(sizeof(wchar_t) == sizeof(__be16));
 94 
 95         switch (endian) {
 96         default:
 97                 *s = (wchar_t)c;
 98                 break;
 99         case UTF16_LITTLE_ENDIAN:
100                 *(__le16 *)s = __cpu_to_le16(c);
101                 break;
102         case UTF16_BIG_ENDIAN:
103                 *(__be16 *)s = __cpu_to_be16(c);
104                 break;
105         }
106 }
107 
108 /*
109  * _utf8s_to_utf16s
110  *
111  * Modified version of 'utf8s_to_utf16s' allows to
112  * detect -ENAMETOOLONG without writing out of expected maximum.
113  */
114 static int _utf8s_to_utf16s(const u8 *s, int inlen, enum utf16_endian endian,
115                             wchar_t *pwcs, int maxout)
116 {
117         u16 *op;
118         int size;
119         unicode_t u;
120 
121         op = pwcs;
122         while (inlen > 0 && *s) {
123                 if (*s & 0x80) {
124                         size = utf8_to_utf32(s, inlen, &u);
125                         if (size < 0)
126                                 return -EINVAL;
127                         s += size;
128                         inlen -= size;
129 
130                         if (u >= PLANE_SIZE) {
131                                 if (maxout < 2)
132                                         return -ENAMETOOLONG;
133 
134                                 u -= PLANE_SIZE;
135                                 put_utf16(op++,
136                                           SURROGATE_PAIR |
137                                                   ((u >> 10) & SURROGATE_BITS),
138                                           endian);
139                                 put_utf16(op++,
140                                           SURROGATE_PAIR | SURROGATE_LOW |
141                                                   (u & SURROGATE_BITS),
142                                           endian);
143                                 maxout -= 2;
144                         } else {
145                                 if (maxout < 1)
146                                         return -ENAMETOOLONG;
147 
148                                 put_utf16(op++, u, endian);
149                                 maxout--;
150                         }
151                 } else {
152                         if (maxout < 1)
153                                 return -ENAMETOOLONG;
154 
155                         put_utf16(op++, *s++, endian);
156                         inlen--;
157                         maxout--;
158                 }
159         }
160         return op - pwcs;
161 }
162 
163 /*
164  * ntfs_nls_to_utf16 - Convert input string to UTF-16.
165  * @name:       Input name.
166  * @name_len:   Input name length.
167  * @uni:        Destination memory.
168  * @max_ulen:   Destination memory.
169  * @endian:     Endian of target UTF-16 string.
170  *
171  * This function is called:
172  * - to create NTFS name
173  * - to create symlink
174  *
175  * Return: UTF-16 string length or error (if negative).
176  */
177 int ntfs_nls_to_utf16(struct ntfs_sb_info *sbi, const u8 *name, u32 name_len,
178                       struct cpu_str *uni, u32 max_ulen,
179                       enum utf16_endian endian)
180 {
181         int ret, slen;
182         const u8 *end;
183         struct nls_table *nls = sbi->options->nls;
184         u16 *uname = uni->name;
185 
186         static_assert(sizeof(wchar_t) == sizeof(u16));
187 
188         if (!nls) {
189                 /* utf8 -> utf16 */
190                 ret = _utf8s_to_utf16s(name, name_len, endian, uname, max_ulen);
191                 uni->len = ret;
192                 return ret;
193         }
194 
195         for (ret = 0, end = name + name_len; name < end; ret++, name += slen) {
196                 if (ret >= max_ulen)
197                         return -ENAMETOOLONG;
198 
199                 slen = nls->char2uni(name, end - name, uname + ret);
200                 if (!slen)
201                         return -EINVAL;
202                 if (slen < 0)
203                         return slen;
204         }
205 
206 #ifdef __BIG_ENDIAN
207         if (endian == UTF16_LITTLE_ENDIAN) {
208                 int i = ret;
209 
210                 while (i--) {
211                         __cpu_to_le16s(uname);
212                         uname++;
213                 }
214         }
215 #else
216         if (endian == UTF16_BIG_ENDIAN) {
217                 int i = ret;
218 
219                 while (i--) {
220                         __cpu_to_be16s(uname);
221                         uname++;
222                 }
223         }
224 #endif
225 
226         uni->len = ret;
227         return ret;
228 }
229 
230 /*
231  * dir_search_u - Helper function.
232  */
233 struct inode *dir_search_u(struct inode *dir, const struct cpu_str *uni,
234                            struct ntfs_fnd *fnd)
235 {
236         int err = 0;
237         struct super_block *sb = dir->i_sb;
238         struct ntfs_sb_info *sbi = sb->s_fs_info;
239         struct ntfs_inode *ni = ntfs_i(dir);
240         struct NTFS_DE *e;
241         int diff;
242         struct inode *inode = NULL;
243         struct ntfs_fnd *fnd_a = NULL;
244 
245         if (!fnd) {
246                 fnd_a = fnd_get();
247                 if (!fnd_a) {
248                         err = -ENOMEM;
249                         goto out;
250                 }
251                 fnd = fnd_a;
252         }
253 
254         err = indx_find(&ni->dir, ni, NULL, uni, 0, sbi, &diff, &e, fnd);
255 
256         if (err)
257                 goto out;
258 
259         if (diff) {
260                 err = -ENOENT;
261                 goto out;
262         }
263 
264         inode = ntfs_iget5(sb, &e->ref, uni);
265         if (!IS_ERR(inode) && is_bad_inode(inode)) {
266                 iput(inode);
267                 err = -EINVAL;
268         }
269 out:
270         fnd_put(fnd_a);
271 
272         return err == -ENOENT ? NULL : err ? ERR_PTR(err) : inode;
273 }
274 
275 static inline int ntfs_filldir(struct ntfs_sb_info *sbi, struct ntfs_inode *ni,
276                                const struct NTFS_DE *e, u8 *name,
277                                struct dir_context *ctx)
278 {
279         const struct ATTR_FILE_NAME *fname;
280         unsigned long ino;
281         int name_len;
282         u32 dt_type;
283 
284         fname = Add2Ptr(e, sizeof(struct NTFS_DE));
285 
286         if (fname->type == FILE_NAME_DOS)
287                 return 0;
288 
289         if (!mi_is_ref(&ni->mi, &fname->home))
290                 return 0;
291 
292         ino = ino_get(&e->ref);
293 
294         if (ino == MFT_REC_ROOT)
295                 return 0;
296 
297         /* Skip meta files. Unless option to show metafiles is set. */
298         if (!sbi->options->showmeta && ntfs_is_meta_file(sbi, ino))
299                 return 0;
300 
301         if (sbi->options->nohidden && (fname->dup.fa & FILE_ATTRIBUTE_HIDDEN))
302                 return 0;
303 
304         name_len = ntfs_utf16_to_nls(sbi, fname->name, fname->name_len, name,
305                                      PATH_MAX);
306         if (name_len <= 0) {
307                 ntfs_warn(sbi->sb, "failed to convert name for inode %lx.",
308                           ino);
309                 return 0;
310         }
311 
312         dt_type = (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY) ? DT_DIR : DT_REG;
313 
314         return !dir_emit(ctx, (s8 *)name, name_len, ino, dt_type);
315 }
316 
317 /*
318  * ntfs_read_hdr - Helper function for ntfs_readdir().
319  */
320 static int ntfs_read_hdr(struct ntfs_sb_info *sbi, struct ntfs_inode *ni,
321                          const struct INDEX_HDR *hdr, u64 vbo, u64 pos,
322                          u8 *name, struct dir_context *ctx)
323 {
324         int err;
325         const struct NTFS_DE *e;
326         u32 e_size;
327         u32 end = le32_to_cpu(hdr->used);
328         u32 off = le32_to_cpu(hdr->de_off);
329 
330         for (;; off += e_size) {
331                 if (off + sizeof(struct NTFS_DE) > end)
332                         return -1;
333 
334                 e = Add2Ptr(hdr, off);
335                 e_size = le16_to_cpu(e->size);
336                 if (e_size < sizeof(struct NTFS_DE) || off + e_size > end)
337                         return -1;
338 
339                 if (de_is_last(e))
340                         return 0;
341 
342                 /* Skip already enumerated. */
343                 if (vbo + off < pos)
344                         continue;
345 
346                 if (le16_to_cpu(e->key_size) < SIZEOF_ATTRIBUTE_FILENAME)
347                         return -1;
348 
349                 ctx->pos = vbo + off;
350 
351                 /* Submit the name to the filldir callback. */
352                 err = ntfs_filldir(sbi, ni, e, name, ctx);
353                 if (err)
354                         return err;
355         }
356 }
357 
358 /*
359  * ntfs_readdir - file_operations::iterate_shared
360  *
361  * Use non sorted enumeration.
362  * We have an example of broken volume where sorted enumeration
363  * counts each name twice.
364  */
365 static int ntfs_readdir(struct file *file, struct dir_context *ctx)
366 {
367         const struct INDEX_ROOT *root;
368         u64 vbo;
369         size_t bit;
370         loff_t eod;
371         int err = 0;
372         struct inode *dir = file_inode(file);
373         struct ntfs_inode *ni = ntfs_i(dir);
374         struct super_block *sb = dir->i_sb;
375         struct ntfs_sb_info *sbi = sb->s_fs_info;
376         loff_t i_size = i_size_read(dir);
377         u32 pos = ctx->pos;
378         u8 *name = NULL;
379         struct indx_node *node = NULL;
380         u8 index_bits = ni->dir.index_bits;
381 
382         /* Name is a buffer of PATH_MAX length. */
383         static_assert(NTFS_NAME_LEN * 4 < PATH_MAX);
384 
385         eod = i_size + sbi->record_size;
386 
387         if (pos >= eod)
388                 return 0;
389 
390         if (!dir_emit_dots(file, ctx))
391                 return 0;
392 
393         /* Allocate PATH_MAX bytes. */
394         name = __getname();
395         if (!name)
396                 return -ENOMEM;
397 
398         if (!ni->mi_loaded && ni->attr_list.size) {
399                 /*
400                  * Directory inode is locked for read.
401                  * Load all subrecords to avoid 'write' access to 'ni' during
402                  * directory reading.
403                  */
404                 ni_lock(ni);
405                 if (!ni->mi_loaded && ni->attr_list.size) {
406                         err = ni_load_all_mi(ni);
407                         if (!err)
408                                 ni->mi_loaded = true;
409                 }
410                 ni_unlock(ni);
411                 if (err)
412                         goto out;
413         }
414 
415         root = indx_get_root(&ni->dir, ni, NULL, NULL);
416         if (!root) {
417                 err = -EINVAL;
418                 goto out;
419         }
420 
421         if (pos >= sbi->record_size) {
422                 bit = (pos - sbi->record_size) >> index_bits;
423         } else {
424                 err = ntfs_read_hdr(sbi, ni, &root->ihdr, 0, pos, name, ctx);
425                 if (err)
426                         goto out;
427                 bit = 0;
428         }
429 
430         if (!i_size) {
431                 ctx->pos = eod;
432                 goto out;
433         }
434 
435         for (;;) {
436                 vbo = (u64)bit << index_bits;
437                 if (vbo >= i_size) {
438                         ctx->pos = eod;
439                         goto out;
440                 }
441 
442                 err = indx_used_bit(&ni->dir, ni, &bit);
443                 if (err)
444                         goto out;
445 
446                 if (bit == MINUS_ONE_T) {
447                         ctx->pos = eod;
448                         goto out;
449                 }
450 
451                 vbo = (u64)bit << index_bits;
452                 if (vbo >= i_size) {
453                         ntfs_inode_err(dir, "Looks like your dir is corrupt");
454                         err = -EINVAL;
455                         goto out;
456                 }
457 
458                 err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits,
459                                 &node);
460                 if (err)
461                         goto out;
462 
463                 err = ntfs_read_hdr(sbi, ni, &node->index->ihdr,
464                                     vbo + sbi->record_size, pos, name, ctx);
465                 if (err)
466                         goto out;
467 
468                 bit += 1;
469         }
470 
471 out:
472 
473         __putname(name);
474         put_indx_node(node);
475 
476         if (err == -ENOENT) {
477                 err = 0;
478                 ctx->pos = pos;
479         }
480 
481         return err;
482 }
483 
484 static int ntfs_dir_count(struct inode *dir, bool *is_empty, size_t *dirs,
485                           size_t *files)
486 {
487         int err = 0;
488         struct ntfs_inode *ni = ntfs_i(dir);
489         struct NTFS_DE *e = NULL;
490         struct INDEX_ROOT *root;
491         struct INDEX_HDR *hdr;
492         const struct ATTR_FILE_NAME *fname;
493         u32 e_size, off, end;
494         u64 vbo = 0;
495         size_t drs = 0, fles = 0, bit = 0;
496         loff_t i_size = ni->vfs_inode.i_size;
497         struct indx_node *node = NULL;
498         u8 index_bits = ni->dir.index_bits;
499 
500         if (is_empty)
501                 *is_empty = true;
502 
503         root = indx_get_root(&ni->dir, ni, NULL, NULL);
504         if (!root)
505                 return -EINVAL;
506 
507         hdr = &root->ihdr;
508 
509         for (;;) {
510                 end = le32_to_cpu(hdr->used);
511                 off = le32_to_cpu(hdr->de_off);
512 
513                 for (; off + sizeof(struct NTFS_DE) <= end; off += e_size) {
514                         e = Add2Ptr(hdr, off);
515                         e_size = le16_to_cpu(e->size);
516                         if (e_size < sizeof(struct NTFS_DE) ||
517                             off + e_size > end)
518                                 break;
519 
520                         if (de_is_last(e))
521                                 break;
522 
523                         fname = de_get_fname(e);
524                         if (!fname)
525                                 continue;
526 
527                         if (fname->type == FILE_NAME_DOS)
528                                 continue;
529 
530                         if (is_empty) {
531                                 *is_empty = false;
532                                 if (!dirs && !files)
533                                         goto out;
534                         }
535 
536                         if (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY)
537                                 drs += 1;
538                         else
539                                 fles += 1;
540                 }
541 
542                 if (vbo >= i_size)
543                         goto out;
544 
545                 err = indx_used_bit(&ni->dir, ni, &bit);
546                 if (err)
547                         goto out;
548 
549                 if (bit == MINUS_ONE_T)
550                         goto out;
551 
552                 vbo = (u64)bit << index_bits;
553                 if (vbo >= i_size)
554                         goto out;
555 
556                 err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits,
557                                 &node);
558                 if (err)
559                         goto out;
560 
561                 hdr = &node->index->ihdr;
562                 bit += 1;
563                 vbo = (u64)bit << ni->dir.idx2vbn_bits;
564         }
565 
566 out:
567         put_indx_node(node);
568         if (dirs)
569                 *dirs = drs;
570         if (files)
571                 *files = fles;
572 
573         return err;
574 }
575 
576 bool dir_is_empty(struct inode *dir)
577 {
578         bool is_empty = false;
579 
580         ntfs_dir_count(dir, &is_empty, NULL, NULL);
581 
582         return is_empty;
583 }
584 
585 // clang-format off
586 const struct file_operations ntfs_dir_operations = {
587         .llseek         = generic_file_llseek,
588         .read           = generic_read_dir,
589         .iterate_shared = ntfs_readdir,
590         .fsync          = generic_file_fsync,
591         .open           = ntfs_file_open,
592 };
593 // clang-format on
594 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp