1 | // SPDX-License-Identifier: GPL-2.0-or-later |
---|---|
2 | /* |
3 | * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd. |
4 | */ |
5 | |
6 | #include <linux/slab.h> |
7 | #include <linux/compat.h> |
8 | #include <linux/bio.h> |
9 | #include <linux/buffer_head.h> |
10 | |
11 | #include "exfat_raw.h" |
12 | #include "exfat_fs.h" |
13 | |
14 | static int exfat_extract_uni_name(struct exfat_dentry *ep, |
15 | unsigned short *uniname) |
16 | { |
17 | int i, len = 0; |
18 | |
19 | for (i = 0; i < EXFAT_FILE_NAME_LEN; i++) { |
20 | *uniname = le16_to_cpu(ep->dentry.name.unicode_0_14[i]); |
21 | if (*uniname == 0x0) |
22 | return len; |
23 | uniname++; |
24 | len++; |
25 | } |
26 | |
27 | *uniname = 0x0; |
28 | return len; |
29 | |
30 | } |
31 | |
32 | static int exfat_get_uniname_from_ext_entry(struct super_block *sb, |
33 | struct exfat_chain *p_dir, int entry, unsigned short *uniname) |
34 | { |
35 | int i, err; |
36 | struct exfat_entry_set_cache es; |
37 | unsigned int uni_len = 0, len; |
38 | |
39 | err = exfat_get_dentry_set(es: &es, sb, p_dir, entry, ES_ALL_ENTRIES); |
40 | if (err) |
41 | return err; |
42 | |
43 | /* |
44 | * First entry : file entry |
45 | * Second entry : stream-extension entry |
46 | * Third entry : first file-name entry |
47 | * So, the index of first file-name dentry should start from 2. |
48 | */ |
49 | for (i = ES_IDX_FIRST_FILENAME; i < es.num_entries; i++) { |
50 | struct exfat_dentry *ep = exfat_get_dentry_cached(es: &es, num: i); |
51 | |
52 | /* end of name entry */ |
53 | if (exfat_get_entry_type(p_entry: ep) != TYPE_EXTEND) |
54 | break; |
55 | |
56 | len = exfat_extract_uni_name(ep, uniname); |
57 | uni_len += len; |
58 | if (len != EXFAT_FILE_NAME_LEN || uni_len >= MAX_NAME_LENGTH) |
59 | break; |
60 | uniname += EXFAT_FILE_NAME_LEN; |
61 | } |
62 | |
63 | exfat_put_dentry_set(es: &es, sync: false); |
64 | return 0; |
65 | } |
66 | |
67 | /* read a directory entry from the opened directory */ |
68 | static int exfat_readdir(struct inode *inode, loff_t *cpos, struct exfat_dir_entry *dir_entry) |
69 | { |
70 | int i, dentries_per_clu, num_ext, err; |
71 | unsigned int type, clu_offset, max_dentries; |
72 | struct exfat_chain dir, clu; |
73 | struct exfat_uni_name uni_name; |
74 | struct exfat_dentry *ep; |
75 | struct super_block *sb = inode->i_sb; |
76 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
77 | struct exfat_inode_info *ei = EXFAT_I(inode); |
78 | unsigned int dentry = EXFAT_B_TO_DEN(*cpos) & 0xFFFFFFFF; |
79 | struct buffer_head *bh; |
80 | |
81 | /* check if the given file ID is opened */ |
82 | if (ei->type != TYPE_DIR) |
83 | return -EPERM; |
84 | |
85 | exfat_chain_set(ec: &dir, dir: ei->start_clu, |
86 | EXFAT_B_TO_CLU(i_size_read(inode), sbi), flags: ei->flags); |
87 | |
88 | dentries_per_clu = sbi->dentries_per_clu; |
89 | max_dentries = (unsigned int)min_t(u64, MAX_EXFAT_DENTRIES, |
90 | (u64)EXFAT_CLU_TO_DEN(sbi->num_clusters, sbi)); |
91 | |
92 | clu_offset = EXFAT_DEN_TO_CLU(dentry, sbi); |
93 | exfat_chain_dup(dup: &clu, ec: &dir); |
94 | |
95 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { |
96 | clu.dir += clu_offset; |
97 | clu.size -= clu_offset; |
98 | } else { |
99 | /* hint_information */ |
100 | if (clu_offset > 0 && ei->hint_bmap.off != EXFAT_EOF_CLUSTER && |
101 | ei->hint_bmap.off > 0 && clu_offset >= ei->hint_bmap.off) { |
102 | clu_offset -= ei->hint_bmap.off; |
103 | clu.dir = ei->hint_bmap.clu; |
104 | } |
105 | |
106 | while (clu_offset > 0 && clu.dir != EXFAT_EOF_CLUSTER) { |
107 | if (exfat_get_next_cluster(sb, &(clu.dir))) |
108 | return -EIO; |
109 | |
110 | clu_offset--; |
111 | } |
112 | } |
113 | |
114 | while (clu.dir != EXFAT_EOF_CLUSTER && dentry < max_dentries) { |
115 | i = dentry & (dentries_per_clu - 1); |
116 | |
117 | for ( ; i < dentries_per_clu; i++, dentry++) { |
118 | ep = exfat_get_dentry(sb, p_dir: &clu, entry: i, bh: &bh); |
119 | if (!ep) |
120 | return -EIO; |
121 | |
122 | type = exfat_get_entry_type(p_entry: ep); |
123 | if (type == TYPE_UNUSED) { |
124 | brelse(bh); |
125 | goto out; |
126 | } |
127 | |
128 | if (type != TYPE_FILE && type != TYPE_DIR) { |
129 | brelse(bh); |
130 | continue; |
131 | } |
132 | |
133 | num_ext = ep->dentry.file.num_ext; |
134 | dir_entry->attr = le16_to_cpu(ep->dentry.file.attr); |
135 | |
136 | *uni_name.name = 0x0; |
137 | err = exfat_get_uniname_from_ext_entry(sb, p_dir: &clu, entry: i, |
138 | uniname: uni_name.name); |
139 | if (err) { |
140 | brelse(bh); |
141 | continue; |
142 | } |
143 | exfat_utf16_to_nls(sb, uniname: &uni_name, |
144 | p_cstring: dir_entry->namebuf.lfn, |
145 | len: dir_entry->namebuf.lfnbuf_len); |
146 | brelse(bh); |
147 | |
148 | ep = exfat_get_dentry(sb, p_dir: &clu, entry: i + 1, bh: &bh); |
149 | if (!ep) |
150 | return -EIO; |
151 | dir_entry->entry = i; |
152 | dir_entry->dir = clu; |
153 | brelse(bh); |
154 | |
155 | ei->hint_bmap.off = EXFAT_DEN_TO_CLU(dentry, sbi); |
156 | ei->hint_bmap.clu = clu.dir; |
157 | |
158 | *cpos = EXFAT_DEN_TO_B(dentry + 1 + num_ext); |
159 | return 0; |
160 | } |
161 | |
162 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { |
163 | if (--clu.size > 0) |
164 | clu.dir++; |
165 | else |
166 | clu.dir = EXFAT_EOF_CLUSTER; |
167 | } else { |
168 | if (exfat_get_next_cluster(sb, &(clu.dir))) |
169 | return -EIO; |
170 | } |
171 | } |
172 | |
173 | out: |
174 | dir_entry->namebuf.lfn[0] = '\0'; |
175 | *cpos = EXFAT_DEN_TO_B(dentry); |
176 | return 0; |
177 | } |
178 | |
179 | static void exfat_init_namebuf(struct exfat_dentry_namebuf *nb) |
180 | { |
181 | nb->lfn = NULL; |
182 | nb->lfnbuf_len = 0; |
183 | } |
184 | |
185 | static int exfat_alloc_namebuf(struct exfat_dentry_namebuf *nb) |
186 | { |
187 | nb->lfn = __getname(); |
188 | if (!nb->lfn) |
189 | return -ENOMEM; |
190 | nb->lfnbuf_len = MAX_VFSNAME_BUF_SIZE; |
191 | return 0; |
192 | } |
193 | |
194 | static void exfat_free_namebuf(struct exfat_dentry_namebuf *nb) |
195 | { |
196 | if (!nb->lfn) |
197 | return; |
198 | |
199 | __putname(nb->lfn); |
200 | exfat_init_namebuf(nb); |
201 | } |
202 | |
203 | /* |
204 | * Before calling dir_emit*(), sbi->s_lock should be released |
205 | * because page fault can occur in dir_emit*(). |
206 | */ |
207 | #define ITER_POS_FILLED_DOTS (2) |
208 | static int exfat_iterate(struct file *file, struct dir_context *ctx) |
209 | { |
210 | struct inode *inode = file_inode(f: file); |
211 | struct super_block *sb = inode->i_sb; |
212 | struct inode *tmp; |
213 | struct exfat_dir_entry de; |
214 | struct exfat_dentry_namebuf *nb = &(de.namebuf); |
215 | struct exfat_inode_info *ei = EXFAT_I(inode); |
216 | unsigned long inum; |
217 | loff_t cpos, i_pos; |
218 | int err = 0, fake_offset = 0; |
219 | |
220 | exfat_init_namebuf(nb); |
221 | |
222 | cpos = ctx->pos; |
223 | if (!dir_emit_dots(file, ctx)) |
224 | goto out; |
225 | |
226 | if (ctx->pos == ITER_POS_FILLED_DOTS) { |
227 | cpos = 0; |
228 | fake_offset = 1; |
229 | } |
230 | |
231 | cpos = round_up(cpos, DENTRY_SIZE); |
232 | |
233 | /* name buffer should be allocated before use */ |
234 | err = exfat_alloc_namebuf(nb); |
235 | if (err) |
236 | goto out; |
237 | get_new: |
238 | mutex_lock(&EXFAT_SB(sb)->s_lock); |
239 | |
240 | if (ei->flags == ALLOC_NO_FAT_CHAIN && cpos >= i_size_read(inode)) |
241 | goto end_of_dir; |
242 | |
243 | err = exfat_readdir(inode, cpos: &cpos, dir_entry: &de); |
244 | if (err) { |
245 | /* |
246 | * At least we tried to read a sector. |
247 | * Move cpos to next sector position (should be aligned). |
248 | */ |
249 | if (err == -EIO) { |
250 | cpos += 1 << (sb->s_blocksize_bits); |
251 | cpos &= ~(sb->s_blocksize - 1); |
252 | } |
253 | |
254 | err = -EIO; |
255 | goto end_of_dir; |
256 | } |
257 | |
258 | if (!nb->lfn[0]) |
259 | goto end_of_dir; |
260 | |
261 | i_pos = ((loff_t)de.dir.dir << 32) | (de.entry & 0xffffffff); |
262 | tmp = exfat_iget(sb, i_pos); |
263 | if (tmp) { |
264 | inum = tmp->i_ino; |
265 | iput(tmp); |
266 | } else { |
267 | inum = iunique(sb, EXFAT_ROOT_INO); |
268 | } |
269 | |
270 | mutex_unlock(lock: &EXFAT_SB(sb)->s_lock); |
271 | if (!dir_emit(ctx, name: nb->lfn, strlen(nb->lfn), ino: inum, |
272 | type: (de.attr & EXFAT_ATTR_SUBDIR) ? DT_DIR : DT_REG)) |
273 | goto out; |
274 | ctx->pos = cpos; |
275 | goto get_new; |
276 | |
277 | end_of_dir: |
278 | if (!cpos && fake_offset) |
279 | cpos = ITER_POS_FILLED_DOTS; |
280 | ctx->pos = cpos; |
281 | mutex_unlock(lock: &EXFAT_SB(sb)->s_lock); |
282 | out: |
283 | /* |
284 | * To improve performance, free namebuf after unlock sb_lock. |
285 | * If namebuf is not allocated, this function do nothing |
286 | */ |
287 | exfat_free_namebuf(nb); |
288 | return err; |
289 | } |
290 | |
291 | WRAP_DIR_ITER(exfat_iterate) // FIXME! |
292 | const struct file_operations exfat_dir_operations = { |
293 | .llseek = generic_file_llseek, |
294 | .read = generic_read_dir, |
295 | .iterate_shared = shared_exfat_iterate, |
296 | .unlocked_ioctl = exfat_ioctl, |
297 | #ifdef CONFIG_COMPAT |
298 | .compat_ioctl = exfat_compat_ioctl, |
299 | #endif |
300 | .fsync = exfat_file_fsync, |
301 | }; |
302 | |
303 | int exfat_alloc_new_dir(struct inode *inode, struct exfat_chain *clu) |
304 | { |
305 | int ret; |
306 | |
307 | exfat_chain_set(ec: clu, EXFAT_EOF_CLUSTER, size: 0, ALLOC_NO_FAT_CHAIN); |
308 | |
309 | ret = exfat_alloc_cluster(inode, num_alloc: 1, p_chain: clu, IS_DIRSYNC(inode)); |
310 | if (ret) |
311 | return ret; |
312 | |
313 | return exfat_zeroed_cluster(dir: inode, clu: clu->dir); |
314 | } |
315 | |
316 | int exfat_calc_num_entries(struct exfat_uni_name *p_uniname) |
317 | { |
318 | int len; |
319 | |
320 | len = p_uniname->name_len; |
321 | if (len == 0) |
322 | return -EINVAL; |
323 | |
324 | /* 1 file entry + 1 stream entry + name entries */ |
325 | return ES_ENTRY_NUM(len); |
326 | } |
327 | |
328 | unsigned int exfat_get_entry_type(struct exfat_dentry *ep) |
329 | { |
330 | if (ep->type == EXFAT_UNUSED) |
331 | return TYPE_UNUSED; |
332 | if (IS_EXFAT_DELETED(ep->type)) |
333 | return TYPE_DELETED; |
334 | if (ep->type == EXFAT_INVAL) |
335 | return TYPE_INVALID; |
336 | if (IS_EXFAT_CRITICAL_PRI(ep->type)) { |
337 | if (ep->type == EXFAT_BITMAP) |
338 | return TYPE_BITMAP; |
339 | if (ep->type == EXFAT_UPCASE) |
340 | return TYPE_UPCASE; |
341 | if (ep->type == EXFAT_VOLUME) |
342 | return TYPE_VOLUME; |
343 | if (ep->type == EXFAT_FILE) { |
344 | if (le16_to_cpu(ep->dentry.file.attr) & EXFAT_ATTR_SUBDIR) |
345 | return TYPE_DIR; |
346 | return TYPE_FILE; |
347 | } |
348 | return TYPE_CRITICAL_PRI; |
349 | } |
350 | if (IS_EXFAT_BENIGN_PRI(ep->type)) { |
351 | if (ep->type == EXFAT_GUID) |
352 | return TYPE_GUID; |
353 | if (ep->type == EXFAT_PADDING) |
354 | return TYPE_PADDING; |
355 | if (ep->type == EXFAT_ACLTAB) |
356 | return TYPE_ACLTAB; |
357 | return TYPE_BENIGN_PRI; |
358 | } |
359 | if (IS_EXFAT_CRITICAL_SEC(ep->type)) { |
360 | if (ep->type == EXFAT_STREAM) |
361 | return TYPE_STREAM; |
362 | if (ep->type == EXFAT_NAME) |
363 | return TYPE_EXTEND; |
364 | if (ep->type == EXFAT_ACL) |
365 | return TYPE_ACL; |
366 | return TYPE_CRITICAL_SEC; |
367 | } |
368 | |
369 | if (ep->type == EXFAT_VENDOR_EXT) |
370 | return TYPE_VENDOR_EXT; |
371 | if (ep->type == EXFAT_VENDOR_ALLOC) |
372 | return TYPE_VENDOR_ALLOC; |
373 | |
374 | return TYPE_BENIGN_SEC; |
375 | } |
376 | |
377 | static void exfat_set_entry_type(struct exfat_dentry *ep, unsigned int type) |
378 | { |
379 | if (type == TYPE_UNUSED) { |
380 | ep->type = EXFAT_UNUSED; |
381 | } else if (type == TYPE_DELETED) { |
382 | ep->type &= EXFAT_DELETE; |
383 | } else if (type == TYPE_STREAM) { |
384 | ep->type = EXFAT_STREAM; |
385 | } else if (type == TYPE_EXTEND) { |
386 | ep->type = EXFAT_NAME; |
387 | } else if (type == TYPE_BITMAP) { |
388 | ep->type = EXFAT_BITMAP; |
389 | } else if (type == TYPE_UPCASE) { |
390 | ep->type = EXFAT_UPCASE; |
391 | } else if (type == TYPE_VOLUME) { |
392 | ep->type = EXFAT_VOLUME; |
393 | } else if (type == TYPE_DIR) { |
394 | ep->type = EXFAT_FILE; |
395 | ep->dentry.file.attr = cpu_to_le16(EXFAT_ATTR_SUBDIR); |
396 | } else if (type == TYPE_FILE) { |
397 | ep->type = EXFAT_FILE; |
398 | ep->dentry.file.attr = cpu_to_le16(EXFAT_ATTR_ARCHIVE); |
399 | } |
400 | } |
401 | |
402 | static void exfat_init_stream_entry(struct exfat_dentry *ep, |
403 | unsigned int start_clu, unsigned long long size) |
404 | { |
405 | memset(ep, 0, sizeof(*ep)); |
406 | exfat_set_entry_type(ep, TYPE_STREAM); |
407 | if (size == 0) |
408 | ep->dentry.stream.flags = ALLOC_FAT_CHAIN; |
409 | else |
410 | ep->dentry.stream.flags = ALLOC_NO_FAT_CHAIN; |
411 | ep->dentry.stream.start_clu = cpu_to_le32(start_clu); |
412 | ep->dentry.stream.valid_size = cpu_to_le64(size); |
413 | ep->dentry.stream.size = cpu_to_le64(size); |
414 | } |
415 | |
416 | static void exfat_init_name_entry(struct exfat_dentry *ep, |
417 | unsigned short *uniname) |
418 | { |
419 | int i; |
420 | |
421 | exfat_set_entry_type(ep, TYPE_EXTEND); |
422 | ep->dentry.name.flags = 0x0; |
423 | |
424 | for (i = 0; i < EXFAT_FILE_NAME_LEN; i++) { |
425 | if (*uniname != 0x0) { |
426 | ep->dentry.name.unicode_0_14[i] = cpu_to_le16(*uniname); |
427 | uniname++; |
428 | } else { |
429 | ep->dentry.name.unicode_0_14[i] = 0x0; |
430 | } |
431 | } |
432 | } |
433 | |
434 | void exfat_init_dir_entry(struct exfat_entry_set_cache *es, |
435 | unsigned int type, unsigned int start_clu, |
436 | unsigned long long size, struct timespec64 *ts) |
437 | { |
438 | struct super_block *sb = es->sb; |
439 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
440 | struct exfat_dentry *ep; |
441 | |
442 | ep = exfat_get_dentry_cached(es, ES_IDX_FILE); |
443 | memset(ep, 0, sizeof(*ep)); |
444 | exfat_set_entry_type(ep, type); |
445 | exfat_set_entry_time(sbi, ts, |
446 | tz: &ep->dentry.file.create_tz, |
447 | time: &ep->dentry.file.create_time, |
448 | date: &ep->dentry.file.create_date, |
449 | time_cs: &ep->dentry.file.create_time_cs); |
450 | exfat_set_entry_time(sbi, ts, |
451 | tz: &ep->dentry.file.modify_tz, |
452 | time: &ep->dentry.file.modify_time, |
453 | date: &ep->dentry.file.modify_date, |
454 | time_cs: &ep->dentry.file.modify_time_cs); |
455 | exfat_set_entry_time(sbi, ts, |
456 | tz: &ep->dentry.file.access_tz, |
457 | time: &ep->dentry.file.access_time, |
458 | date: &ep->dentry.file.access_date, |
459 | NULL); |
460 | |
461 | ep = exfat_get_dentry_cached(es, ES_IDX_STREAM); |
462 | exfat_init_stream_entry(ep, start_clu, size); |
463 | } |
464 | |
465 | static void exfat_free_benign_secondary_clusters(struct inode *inode, |
466 | struct exfat_dentry *ep) |
467 | { |
468 | struct super_block *sb = inode->i_sb; |
469 | struct exfat_chain dir; |
470 | unsigned int start_clu = |
471 | le32_to_cpu(ep->dentry.generic_secondary.start_clu); |
472 | u64 size = le64_to_cpu(ep->dentry.generic_secondary.size); |
473 | unsigned char flags = ep->dentry.generic_secondary.flags; |
474 | |
475 | if (!(flags & ALLOC_POSSIBLE) || !start_clu || !size) |
476 | return; |
477 | |
478 | exfat_chain_set(ec: &dir, dir: start_clu, |
479 | EXFAT_B_TO_CLU_ROUND_UP(size, EXFAT_SB(sb)), |
480 | flags); |
481 | exfat_free_cluster(inode, p_chain: &dir); |
482 | } |
483 | |
484 | void exfat_init_ext_entry(struct exfat_entry_set_cache *es, int num_entries, |
485 | struct exfat_uni_name *p_uniname) |
486 | { |
487 | int i; |
488 | unsigned short *uniname = p_uniname->name; |
489 | struct exfat_dentry *ep; |
490 | |
491 | ep = exfat_get_dentry_cached(es, ES_IDX_FILE); |
492 | ep->dentry.file.num_ext = (unsigned char)(num_entries - 1); |
493 | |
494 | ep = exfat_get_dentry_cached(es, ES_IDX_STREAM); |
495 | ep->dentry.stream.name_len = p_uniname->name_len; |
496 | ep->dentry.stream.name_hash = cpu_to_le16(p_uniname->name_hash); |
497 | |
498 | for (i = ES_IDX_FIRST_FILENAME; i < num_entries; i++) { |
499 | ep = exfat_get_dentry_cached(es, num: i); |
500 | exfat_init_name_entry(ep, uniname); |
501 | uniname += EXFAT_FILE_NAME_LEN; |
502 | } |
503 | |
504 | exfat_update_dir_chksum(es); |
505 | } |
506 | |
507 | void exfat_remove_entries(struct inode *inode, struct exfat_entry_set_cache *es, |
508 | int order) |
509 | { |
510 | int i; |
511 | struct exfat_dentry *ep; |
512 | |
513 | for (i = order; i < es->num_entries; i++) { |
514 | ep = exfat_get_dentry_cached(es, num: i); |
515 | |
516 | if (exfat_get_entry_type(ep) & TYPE_BENIGN_SEC) |
517 | exfat_free_benign_secondary_clusters(inode, ep); |
518 | |
519 | exfat_set_entry_type(ep, TYPE_DELETED); |
520 | } |
521 | |
522 | if (order < es->num_entries) |
523 | es->modified = true; |
524 | } |
525 | |
526 | void exfat_update_dir_chksum(struct exfat_entry_set_cache *es) |
527 | { |
528 | int chksum_type = CS_DIR_ENTRY, i; |
529 | unsigned short chksum = 0; |
530 | struct exfat_dentry *ep; |
531 | |
532 | for (i = ES_IDX_FILE; i < es->num_entries; i++) { |
533 | ep = exfat_get_dentry_cached(es, num: i); |
534 | chksum = exfat_calc_chksum16(data: ep, DENTRY_SIZE, chksum, |
535 | type: chksum_type); |
536 | chksum_type = CS_DEFAULT; |
537 | } |
538 | ep = exfat_get_dentry_cached(es, ES_IDX_FILE); |
539 | ep->dentry.file.checksum = cpu_to_le16(chksum); |
540 | es->modified = true; |
541 | } |
542 | |
543 | int exfat_put_dentry_set(struct exfat_entry_set_cache *es, int sync) |
544 | { |
545 | int i, err = 0; |
546 | |
547 | if (es->modified) |
548 | err = exfat_update_bhs(bhs: es->bh, nr_bhs: es->num_bh, sync); |
549 | |
550 | for (i = 0; i < es->num_bh; i++) |
551 | if (err) |
552 | bforget(bh: es->bh[i]); |
553 | else |
554 | brelse(bh: es->bh[i]); |
555 | |
556 | if (IS_DYNAMIC_ES(es)) |
557 | kfree(objp: es->bh); |
558 | |
559 | return err; |
560 | } |
561 | |
562 | static int exfat_walk_fat_chain(struct super_block *sb, |
563 | struct exfat_chain *p_dir, unsigned int byte_offset, |
564 | unsigned int *clu) |
565 | { |
566 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
567 | unsigned int clu_offset; |
568 | unsigned int cur_clu; |
569 | |
570 | clu_offset = EXFAT_B_TO_CLU(byte_offset, sbi); |
571 | cur_clu = p_dir->dir; |
572 | |
573 | if (p_dir->flags == ALLOC_NO_FAT_CHAIN) { |
574 | cur_clu += clu_offset; |
575 | } else { |
576 | while (clu_offset > 0) { |
577 | if (exfat_get_next_cluster(sb, &cur_clu)) |
578 | return -EIO; |
579 | if (cur_clu == EXFAT_EOF_CLUSTER) { |
580 | exfat_fs_error(sb, |
581 | "invalid dentry access beyond EOF (clu : %u, eidx : %d)", |
582 | p_dir->dir, |
583 | EXFAT_B_TO_DEN(byte_offset)); |
584 | return -EIO; |
585 | } |
586 | clu_offset--; |
587 | } |
588 | } |
589 | |
590 | *clu = cur_clu; |
591 | return 0; |
592 | } |
593 | |
594 | static int exfat_find_location(struct super_block *sb, struct exfat_chain *p_dir, |
595 | int entry, sector_t *sector, int *offset) |
596 | { |
597 | int ret; |
598 | unsigned int off, clu = 0; |
599 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
600 | |
601 | off = EXFAT_DEN_TO_B(entry); |
602 | |
603 | ret = exfat_walk_fat_chain(sb, p_dir, byte_offset: off, clu: &clu); |
604 | if (ret) |
605 | return ret; |
606 | |
607 | /* byte offset in cluster */ |
608 | off = EXFAT_CLU_OFFSET(off, sbi); |
609 | |
610 | /* byte offset in sector */ |
611 | *offset = EXFAT_BLK_OFFSET(off, sb); |
612 | |
613 | /* sector offset in cluster */ |
614 | *sector = EXFAT_B_TO_BLK(off, sb); |
615 | *sector += exfat_cluster_to_sector(sbi, clus: clu); |
616 | return 0; |
617 | } |
618 | |
619 | #define EXFAT_MAX_RA_SIZE (128*1024) |
620 | static int exfat_dir_readahead(struct super_block *sb, sector_t sec) |
621 | { |
622 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
623 | struct buffer_head *bh; |
624 | unsigned int max_ra_count = EXFAT_MAX_RA_SIZE >> sb->s_blocksize_bits; |
625 | unsigned int page_ra_count = PAGE_SIZE >> sb->s_blocksize_bits; |
626 | unsigned int adj_ra_count = max(sbi->sect_per_clus, page_ra_count); |
627 | unsigned int ra_count = min(adj_ra_count, max_ra_count); |
628 | |
629 | /* Read-ahead is not required */ |
630 | if (sbi->sect_per_clus == 1) |
631 | return 0; |
632 | |
633 | if (sec < sbi->data_start_sector) { |
634 | exfat_err(sb, "requested sector is invalid(sect:%llu, root:%llu)", |
635 | (unsigned long long)sec, sbi->data_start_sector); |
636 | return -EIO; |
637 | } |
638 | |
639 | /* Not sector aligned with ra_count, resize ra_count to page size */ |
640 | if ((sec - sbi->data_start_sector) & (ra_count - 1)) |
641 | ra_count = page_ra_count; |
642 | |
643 | bh = sb_find_get_block(sb, block: sec); |
644 | if (!bh || !buffer_uptodate(bh)) { |
645 | unsigned int i; |
646 | |
647 | for (i = 0; i < ra_count; i++) |
648 | sb_breadahead(sb, block: (sector_t)(sec + i)); |
649 | } |
650 | brelse(bh); |
651 | return 0; |
652 | } |
653 | |
654 | struct exfat_dentry *exfat_get_dentry(struct super_block *sb, |
655 | struct exfat_chain *p_dir, int entry, struct buffer_head **bh) |
656 | { |
657 | unsigned int dentries_per_page = EXFAT_B_TO_DEN(PAGE_SIZE); |
658 | int off; |
659 | sector_t sec; |
660 | |
661 | if (p_dir->dir == DIR_DELETED) { |
662 | exfat_err(sb, "abnormal access to deleted dentry"); |
663 | return NULL; |
664 | } |
665 | |
666 | if (exfat_find_location(sb, p_dir, entry, sector: &sec, offset: &off)) |
667 | return NULL; |
668 | |
669 | if (p_dir->dir != EXFAT_FREE_CLUSTER && |
670 | !(entry & (dentries_per_page - 1))) |
671 | exfat_dir_readahead(sb, sec); |
672 | |
673 | *bh = sb_bread(sb, block: sec); |
674 | if (!*bh) |
675 | return NULL; |
676 | |
677 | return (struct exfat_dentry *)((*bh)->b_data + off); |
678 | } |
679 | |
680 | enum exfat_validate_dentry_mode { |
681 | ES_MODE_GET_FILE_ENTRY, |
682 | ES_MODE_GET_STRM_ENTRY, |
683 | ES_MODE_GET_NAME_ENTRY, |
684 | ES_MODE_GET_CRITICAL_SEC_ENTRY, |
685 | ES_MODE_GET_BENIGN_SEC_ENTRY, |
686 | }; |
687 | |
688 | static bool exfat_validate_entry(unsigned int type, |
689 | enum exfat_validate_dentry_mode *mode) |
690 | { |
691 | if (type == TYPE_UNUSED || type == TYPE_DELETED) |
692 | return false; |
693 | |
694 | switch (*mode) { |
695 | case ES_MODE_GET_FILE_ENTRY: |
696 | if (type != TYPE_STREAM) |
697 | return false; |
698 | *mode = ES_MODE_GET_STRM_ENTRY; |
699 | break; |
700 | case ES_MODE_GET_STRM_ENTRY: |
701 | if (type != TYPE_EXTEND) |
702 | return false; |
703 | *mode = ES_MODE_GET_NAME_ENTRY; |
704 | break; |
705 | case ES_MODE_GET_NAME_ENTRY: |
706 | if (type & TYPE_BENIGN_SEC) |
707 | *mode = ES_MODE_GET_BENIGN_SEC_ENTRY; |
708 | else if (type != TYPE_EXTEND) |
709 | return false; |
710 | break; |
711 | case ES_MODE_GET_BENIGN_SEC_ENTRY: |
712 | /* Assume unreconized benign secondary entry */ |
713 | if (!(type & TYPE_BENIGN_SEC)) |
714 | return false; |
715 | break; |
716 | default: |
717 | return false; |
718 | } |
719 | |
720 | return true; |
721 | } |
722 | |
723 | struct exfat_dentry *exfat_get_dentry_cached( |
724 | struct exfat_entry_set_cache *es, int num) |
725 | { |
726 | int off = es->start_off + num * DENTRY_SIZE; |
727 | struct buffer_head *bh = es->bh[EXFAT_B_TO_BLK(off, es->sb)]; |
728 | char *p = bh->b_data + EXFAT_BLK_OFFSET(off, es->sb); |
729 | |
730 | return (struct exfat_dentry *)p; |
731 | } |
732 | |
733 | /* |
734 | * Returns a set of dentries. |
735 | * |
736 | * Note It provides a direct pointer to bh->data via exfat_get_dentry_cached(). |
737 | * User should call exfat_get_dentry_set() after setting 'modified' to apply |
738 | * changes made in this entry set to the real device. |
739 | * |
740 | * in: |
741 | * sb+p_dir+entry: indicates a file/dir |
742 | * num_entries: specifies how many dentries should be included. |
743 | * It will be set to es->num_entries if it is not 0. |
744 | * If num_entries is 0, es->num_entries will be obtained |
745 | * from the first dentry. |
746 | * out: |
747 | * es: pointer of entry set on success. |
748 | * return: |
749 | * 0 on success |
750 | * -error code on failure |
751 | */ |
752 | static int __exfat_get_dentry_set(struct exfat_entry_set_cache *es, |
753 | struct super_block *sb, struct exfat_chain *p_dir, int entry, |
754 | unsigned int num_entries) |
755 | { |
756 | int ret, i, num_bh; |
757 | unsigned int off; |
758 | sector_t sec; |
759 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
760 | struct buffer_head *bh; |
761 | |
762 | if (p_dir->dir == DIR_DELETED) { |
763 | exfat_err(sb, "access to deleted dentry"); |
764 | return -EIO; |
765 | } |
766 | |
767 | ret = exfat_find_location(sb, p_dir, entry, sector: &sec, offset: &off); |
768 | if (ret) |
769 | return ret; |
770 | |
771 | memset(es, 0, sizeof(*es)); |
772 | es->sb = sb; |
773 | es->modified = false; |
774 | es->start_off = off; |
775 | es->bh = es->__bh; |
776 | |
777 | bh = sb_bread(sb, block: sec); |
778 | if (!bh) |
779 | return -EIO; |
780 | es->bh[es->num_bh++] = bh; |
781 | |
782 | if (num_entries == ES_ALL_ENTRIES) { |
783 | struct exfat_dentry *ep; |
784 | |
785 | ep = exfat_get_dentry_cached(es, ES_IDX_FILE); |
786 | if (ep->type != EXFAT_FILE) { |
787 | brelse(bh); |
788 | return -EIO; |
789 | } |
790 | |
791 | num_entries = ep->dentry.file.num_ext + 1; |
792 | } |
793 | |
794 | es->num_entries = num_entries; |
795 | |
796 | num_bh = EXFAT_B_TO_BLK_ROUND_UP(off + num_entries * DENTRY_SIZE, sb); |
797 | if (num_bh > ARRAY_SIZE(es->__bh)) { |
798 | es->bh = kmalloc_array(num_bh, sizeof(*es->bh), GFP_NOFS); |
799 | if (!es->bh) { |
800 | brelse(bh); |
801 | return -ENOMEM; |
802 | } |
803 | es->bh[0] = bh; |
804 | } |
805 | |
806 | for (i = 1; i < num_bh; i++) { |
807 | /* get the next sector */ |
808 | if (exfat_is_last_sector_in_cluster(sbi, sec)) { |
809 | unsigned int clu = exfat_sector_to_cluster(sbi, sec); |
810 | |
811 | if (p_dir->flags == ALLOC_NO_FAT_CHAIN) |
812 | clu++; |
813 | else if (exfat_get_next_cluster(sb, &clu)) |
814 | goto put_es; |
815 | sec = exfat_cluster_to_sector(sbi, clus: clu); |
816 | } else { |
817 | sec++; |
818 | } |
819 | |
820 | bh = sb_bread(sb, block: sec); |
821 | if (!bh) |
822 | goto put_es; |
823 | es->bh[es->num_bh++] = bh; |
824 | } |
825 | |
826 | return 0; |
827 | |
828 | put_es: |
829 | exfat_put_dentry_set(es, sync: false); |
830 | return -EIO; |
831 | } |
832 | |
833 | int exfat_get_dentry_set(struct exfat_entry_set_cache *es, |
834 | struct super_block *sb, struct exfat_chain *p_dir, |
835 | int entry, unsigned int num_entries) |
836 | { |
837 | int ret, i; |
838 | struct exfat_dentry *ep; |
839 | enum exfat_validate_dentry_mode mode = ES_MODE_GET_FILE_ENTRY; |
840 | |
841 | ret = __exfat_get_dentry_set(es, sb, p_dir, entry, num_entries); |
842 | if (ret < 0) |
843 | return ret; |
844 | |
845 | /* validate cached dentries */ |
846 | for (i = ES_IDX_STREAM; i < es->num_entries; i++) { |
847 | ep = exfat_get_dentry_cached(es, num: i); |
848 | if (!exfat_validate_entry(type: exfat_get_entry_type(ep), mode: &mode)) |
849 | goto put_es; |
850 | } |
851 | return 0; |
852 | |
853 | put_es: |
854 | exfat_put_dentry_set(es, sync: false); |
855 | return -EIO; |
856 | } |
857 | |
858 | static int exfat_validate_empty_dentry_set(struct exfat_entry_set_cache *es) |
859 | { |
860 | struct exfat_dentry *ep; |
861 | struct buffer_head *bh; |
862 | int i, off; |
863 | bool unused_hit = false; |
864 | |
865 | /* |
866 | * ONLY UNUSED OR DELETED DENTRIES ARE ALLOWED: |
867 | * Although it violates the specification for a deleted entry to |
868 | * follow an unused entry, some exFAT implementations could work |
869 | * like this. Therefore, to improve compatibility, let's allow it. |
870 | */ |
871 | for (i = 0; i < es->num_entries; i++) { |
872 | ep = exfat_get_dentry_cached(es, num: i); |
873 | if (ep->type == EXFAT_UNUSED) { |
874 | unused_hit = true; |
875 | } else if (!IS_EXFAT_DELETED(ep->type)) { |
876 | if (unused_hit) |
877 | goto err_used_follow_unused; |
878 | i++; |
879 | goto count_skip_entries; |
880 | } |
881 | } |
882 | |
883 | return 0; |
884 | |
885 | err_used_follow_unused: |
886 | off = es->start_off + (i << DENTRY_SIZE_BITS); |
887 | bh = es->bh[EXFAT_B_TO_BLK(off, es->sb)]; |
888 | |
889 | exfat_fs_error(es->sb, |
890 | "in sector %lld, dentry %d should be unused, but 0x%x", |
891 | bh->b_blocknr, off >> DENTRY_SIZE_BITS, ep->type); |
892 | |
893 | return -EIO; |
894 | |
895 | count_skip_entries: |
896 | es->num_entries = EXFAT_B_TO_DEN(EXFAT_BLK_TO_B(es->num_bh, es->sb) - es->start_off); |
897 | for (; i < es->num_entries; i++) { |
898 | ep = exfat_get_dentry_cached(es, num: i); |
899 | if (IS_EXFAT_DELETED(ep->type)) |
900 | break; |
901 | } |
902 | |
903 | return i; |
904 | } |
905 | |
906 | /* |
907 | * Get an empty dentry set. |
908 | * |
909 | * in: |
910 | * sb+p_dir+entry: indicates the empty dentry location |
911 | * num_entries: specifies how many empty dentries should be included. |
912 | * out: |
913 | * es: pointer of empty dentry set on success. |
914 | * return: |
915 | * 0 : on success |
916 | * >0 : the dentries are not empty, the return value is the number of |
917 | * dentries to be skipped for the next lookup. |
918 | * <0 : on failure |
919 | */ |
920 | int exfat_get_empty_dentry_set(struct exfat_entry_set_cache *es, |
921 | struct super_block *sb, struct exfat_chain *p_dir, |
922 | int entry, unsigned int num_entries) |
923 | { |
924 | int ret; |
925 | |
926 | ret = __exfat_get_dentry_set(es, sb, p_dir, entry, num_entries); |
927 | if (ret < 0) |
928 | return ret; |
929 | |
930 | ret = exfat_validate_empty_dentry_set(es); |
931 | if (ret) |
932 | exfat_put_dentry_set(es, sync: false); |
933 | |
934 | return ret; |
935 | } |
936 | |
937 | static inline void exfat_reset_empty_hint(struct exfat_hint_femp *hint_femp) |
938 | { |
939 | hint_femp->eidx = EXFAT_HINT_NONE; |
940 | hint_femp->count = 0; |
941 | } |
942 | |
943 | static inline void exfat_set_empty_hint(struct exfat_inode_info *ei, |
944 | struct exfat_hint_femp *candi_empty, struct exfat_chain *clu, |
945 | int dentry, int num_entries, int entry_type) |
946 | { |
947 | if (ei->hint_femp.eidx == EXFAT_HINT_NONE || |
948 | ei->hint_femp.eidx > dentry) { |
949 | int total_entries = EXFAT_B_TO_DEN(i_size_read(&ei->vfs_inode)); |
950 | |
951 | if (candi_empty->count == 0) { |
952 | candi_empty->cur = *clu; |
953 | candi_empty->eidx = dentry; |
954 | } |
955 | |
956 | if (entry_type == TYPE_UNUSED) |
957 | candi_empty->count += total_entries - dentry; |
958 | else |
959 | candi_empty->count++; |
960 | |
961 | if (candi_empty->count == num_entries || |
962 | candi_empty->count + candi_empty->eidx == total_entries) |
963 | ei->hint_femp = *candi_empty; |
964 | } |
965 | } |
966 | |
967 | enum { |
968 | DIRENT_STEP_FILE, |
969 | DIRENT_STEP_STRM, |
970 | DIRENT_STEP_NAME, |
971 | DIRENT_STEP_SECD, |
972 | }; |
973 | |
974 | /* |
975 | * @ei: inode info of parent directory |
976 | * @p_dir: directory structure of parent directory |
977 | * @num_entries:entry size of p_uniname |
978 | * @hint_opt: If p_uniname is found, filled with optimized dir/entry |
979 | * for traversing cluster chain. |
980 | * @return: |
981 | * >= 0: file directory entry position where the name exists |
982 | * -ENOENT: entry with the name does not exist |
983 | * -EIO: I/O error |
984 | */ |
985 | int exfat_find_dir_entry(struct super_block *sb, struct exfat_inode_info *ei, |
986 | struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname, |
987 | struct exfat_hint *hint_opt) |
988 | { |
989 | int i, rewind = 0, dentry = 0, end_eidx = 0, num_ext = 0, len; |
990 | int order, step, name_len = 0; |
991 | int dentries_per_clu; |
992 | unsigned int entry_type; |
993 | unsigned short *uniname = NULL; |
994 | struct exfat_chain clu; |
995 | struct exfat_hint *hint_stat = &ei->hint_stat; |
996 | struct exfat_hint_femp candi_empty; |
997 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
998 | int num_entries = exfat_calc_num_entries(p_uniname); |
999 | |
1000 | if (num_entries < 0) |
1001 | return num_entries; |
1002 | |
1003 | dentries_per_clu = sbi->dentries_per_clu; |
1004 | |
1005 | exfat_chain_dup(dup: &clu, ec: p_dir); |
1006 | |
1007 | if (hint_stat->eidx) { |
1008 | clu.dir = hint_stat->clu; |
1009 | dentry = hint_stat->eidx; |
1010 | end_eidx = dentry; |
1011 | } |
1012 | |
1013 | exfat_reset_empty_hint(hint_femp: &ei->hint_femp); |
1014 | |
1015 | rewind: |
1016 | order = 0; |
1017 | step = DIRENT_STEP_FILE; |
1018 | exfat_reset_empty_hint(hint_femp: &candi_empty); |
1019 | |
1020 | while (clu.dir != EXFAT_EOF_CLUSTER) { |
1021 | i = dentry & (dentries_per_clu - 1); |
1022 | for (; i < dentries_per_clu; i++, dentry++) { |
1023 | struct exfat_dentry *ep; |
1024 | struct buffer_head *bh; |
1025 | |
1026 | if (rewind && dentry == end_eidx) |
1027 | goto not_found; |
1028 | |
1029 | ep = exfat_get_dentry(sb, p_dir: &clu, entry: i, bh: &bh); |
1030 | if (!ep) |
1031 | return -EIO; |
1032 | |
1033 | entry_type = exfat_get_entry_type(ep); |
1034 | |
1035 | if (entry_type == TYPE_UNUSED || |
1036 | entry_type == TYPE_DELETED) { |
1037 | step = DIRENT_STEP_FILE; |
1038 | |
1039 | exfat_set_empty_hint(ei, candi_empty: &candi_empty, clu: &clu, |
1040 | dentry, num_entries, |
1041 | entry_type); |
1042 | |
1043 | brelse(bh); |
1044 | if (entry_type == TYPE_UNUSED) |
1045 | goto not_found; |
1046 | continue; |
1047 | } |
1048 | |
1049 | exfat_reset_empty_hint(hint_femp: &candi_empty); |
1050 | |
1051 | if (entry_type == TYPE_FILE || entry_type == TYPE_DIR) { |
1052 | step = DIRENT_STEP_FILE; |
1053 | hint_opt->clu = clu.dir; |
1054 | hint_opt->eidx = i; |
1055 | num_ext = ep->dentry.file.num_ext; |
1056 | step = DIRENT_STEP_STRM; |
1057 | brelse(bh); |
1058 | continue; |
1059 | } |
1060 | |
1061 | if (entry_type == TYPE_STREAM) { |
1062 | u16 name_hash; |
1063 | |
1064 | if (step != DIRENT_STEP_STRM) { |
1065 | step = DIRENT_STEP_FILE; |
1066 | brelse(bh); |
1067 | continue; |
1068 | } |
1069 | step = DIRENT_STEP_FILE; |
1070 | name_hash = le16_to_cpu( |
1071 | ep->dentry.stream.name_hash); |
1072 | if (p_uniname->name_hash == name_hash && |
1073 | p_uniname->name_len == |
1074 | ep->dentry.stream.name_len) { |
1075 | step = DIRENT_STEP_NAME; |
1076 | order = 1; |
1077 | name_len = 0; |
1078 | } |
1079 | brelse(bh); |
1080 | continue; |
1081 | } |
1082 | |
1083 | brelse(bh); |
1084 | if (entry_type == TYPE_EXTEND) { |
1085 | unsigned short entry_uniname[16], unichar; |
1086 | |
1087 | if (step != DIRENT_STEP_NAME || |
1088 | name_len >= MAX_NAME_LENGTH) { |
1089 | step = DIRENT_STEP_FILE; |
1090 | continue; |
1091 | } |
1092 | |
1093 | if (++order == 2) |
1094 | uniname = p_uniname->name; |
1095 | else |
1096 | uniname += EXFAT_FILE_NAME_LEN; |
1097 | |
1098 | len = exfat_extract_uni_name(ep, uniname: entry_uniname); |
1099 | name_len += len; |
1100 | |
1101 | unichar = *(uniname+len); |
1102 | *(uniname+len) = 0x0; |
1103 | |
1104 | if (exfat_uniname_ncmp(sb, a: uniname, |
1105 | b: entry_uniname, len)) { |
1106 | step = DIRENT_STEP_FILE; |
1107 | } else if (p_uniname->name_len == name_len) { |
1108 | if (order == num_ext) |
1109 | goto found; |
1110 | step = DIRENT_STEP_SECD; |
1111 | } |
1112 | |
1113 | *(uniname+len) = unichar; |
1114 | continue; |
1115 | } |
1116 | |
1117 | if (entry_type & |
1118 | (TYPE_CRITICAL_SEC | TYPE_BENIGN_SEC)) { |
1119 | if (step == DIRENT_STEP_SECD) { |
1120 | if (++order == num_ext) |
1121 | goto found; |
1122 | continue; |
1123 | } |
1124 | } |
1125 | step = DIRENT_STEP_FILE; |
1126 | } |
1127 | |
1128 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { |
1129 | if (--clu.size > 0) |
1130 | clu.dir++; |
1131 | else |
1132 | clu.dir = EXFAT_EOF_CLUSTER; |
1133 | } else { |
1134 | if (exfat_get_next_cluster(sb, &clu.dir)) |
1135 | return -EIO; |
1136 | } |
1137 | } |
1138 | |
1139 | not_found: |
1140 | /* |
1141 | * We started at not 0 index,so we should try to find target |
1142 | * from 0 index to the index we started at. |
1143 | */ |
1144 | if (!rewind && end_eidx) { |
1145 | rewind = 1; |
1146 | dentry = 0; |
1147 | clu.dir = p_dir->dir; |
1148 | goto rewind; |
1149 | } |
1150 | |
1151 | /* |
1152 | * set the EXFAT_EOF_CLUSTER flag to avoid search |
1153 | * from the beginning again when allocated a new cluster |
1154 | */ |
1155 | if (ei->hint_femp.eidx == EXFAT_HINT_NONE) { |
1156 | ei->hint_femp.cur.dir = EXFAT_EOF_CLUSTER; |
1157 | ei->hint_femp.eidx = p_dir->size * dentries_per_clu; |
1158 | ei->hint_femp.count = 0; |
1159 | } |
1160 | |
1161 | /* initialized hint_stat */ |
1162 | hint_stat->clu = p_dir->dir; |
1163 | hint_stat->eidx = 0; |
1164 | return -ENOENT; |
1165 | |
1166 | found: |
1167 | /* next dentry we'll find is out of this cluster */ |
1168 | if (!((dentry + 1) & (dentries_per_clu - 1))) { |
1169 | int ret = 0; |
1170 | |
1171 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { |
1172 | if (--clu.size > 0) |
1173 | clu.dir++; |
1174 | else |
1175 | clu.dir = EXFAT_EOF_CLUSTER; |
1176 | } else { |
1177 | ret = exfat_get_next_cluster(sb, &clu.dir); |
1178 | } |
1179 | |
1180 | if (ret || clu.dir == EXFAT_EOF_CLUSTER) { |
1181 | /* just initialized hint_stat */ |
1182 | hint_stat->clu = p_dir->dir; |
1183 | hint_stat->eidx = 0; |
1184 | return (dentry - num_ext); |
1185 | } |
1186 | } |
1187 | |
1188 | hint_stat->clu = clu.dir; |
1189 | hint_stat->eidx = dentry + 1; |
1190 | return dentry - num_ext; |
1191 | } |
1192 | |
1193 | int exfat_count_dir_entries(struct super_block *sb, struct exfat_chain *p_dir) |
1194 | { |
1195 | int i, count = 0; |
1196 | int dentries_per_clu; |
1197 | unsigned int entry_type; |
1198 | struct exfat_chain clu; |
1199 | struct exfat_dentry *ep; |
1200 | struct exfat_sb_info *sbi = EXFAT_SB(sb); |
1201 | struct buffer_head *bh; |
1202 | |
1203 | dentries_per_clu = sbi->dentries_per_clu; |
1204 | |
1205 | exfat_chain_dup(dup: &clu, ec: p_dir); |
1206 | |
1207 | while (clu.dir != EXFAT_EOF_CLUSTER) { |
1208 | for (i = 0; i < dentries_per_clu; i++) { |
1209 | ep = exfat_get_dentry(sb, p_dir: &clu, entry: i, bh: &bh); |
1210 | if (!ep) |
1211 | return -EIO; |
1212 | entry_type = exfat_get_entry_type(ep); |
1213 | brelse(bh); |
1214 | |
1215 | if (entry_type == TYPE_UNUSED) |
1216 | return count; |
1217 | if (entry_type != TYPE_DIR) |
1218 | continue; |
1219 | count++; |
1220 | } |
1221 | |
1222 | if (clu.flags == ALLOC_NO_FAT_CHAIN) { |
1223 | if (--clu.size > 0) |
1224 | clu.dir++; |
1225 | else |
1226 | clu.dir = EXFAT_EOF_CLUSTER; |
1227 | } else { |
1228 | if (exfat_get_next_cluster(sb, &(clu.dir))) |
1229 | return -EIO; |
1230 | } |
1231 | } |
1232 | |
1233 | return count; |
1234 | } |
1235 |
Definitions
- exfat_extract_uni_name
- exfat_get_uniname_from_ext_entry
- exfat_readdir
- exfat_init_namebuf
- exfat_alloc_namebuf
- exfat_free_namebuf
- exfat_iterate
- exfat_dir_operations
- exfat_alloc_new_dir
- exfat_calc_num_entries
- exfat_get_entry_type
- exfat_set_entry_type
- exfat_init_stream_entry
- exfat_init_name_entry
- exfat_init_dir_entry
- exfat_free_benign_secondary_clusters
- exfat_init_ext_entry
- exfat_remove_entries
- exfat_update_dir_chksum
- exfat_put_dentry_set
- exfat_walk_fat_chain
- exfat_find_location
- exfat_dir_readahead
- exfat_get_dentry
- exfat_validate_dentry_mode
- exfat_validate_entry
- exfat_get_dentry_cached
- __exfat_get_dentry_set
- exfat_get_dentry_set
- exfat_validate_empty_dentry_set
- exfat_get_empty_dentry_set
- exfat_reset_empty_hint
- exfat_set_empty_hint
- exfat_find_dir_entry
Improve your Profiling and Debugging skills
Find out more