projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'vfs-6.7.misc' of gitolite.kernel.org:pub/scm/linux/kernel/git/vfs/vfs
[linux-block.git] / fs / ntfs3 / fsntfs.c
CommitLineData
82cae269
KK		 1// SPDX-License-Identifier: GPL-2.0
2/*
3 *
4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
5 *
6 */
7
8#include <linux/blkdev.h>
9#include <linux/buffer_head.h>
10#include <linux/fs.h>
b5322eb1 11#include <linux/kernel.h>
7832e123 12#include <linux/nls.h>
82cae269
KK		 13
14#include "debug.h"
15#include "ntfs.h"
16#include "ntfs_fs.h"
17
18// clang-format off
19const struct cpu_str NAME_MFT = {
20 4, 0, { '$', 'M', 'F', 'T' },
21};
22const struct cpu_str NAME_MIRROR = {
23 8, 0, { '$', 'M', 'F', 'T', 'M', 'i', 'r', 'r' },
24};
25const struct cpu_str NAME_LOGFILE = {
26 8, 0, { '$', 'L', 'o', 'g', 'F', 'i', 'l', 'e' },
27};
28const struct cpu_str NAME_VOLUME = {
29 7, 0, { '$', 'V', 'o', 'l', 'u', 'm', 'e' },
30};
31const struct cpu_str NAME_ATTRDEF = {
32 8, 0, { '$', 'A', 't', 't', 'r', 'D', 'e', 'f' },
33};
34const struct cpu_str NAME_ROOT = {
35 1, 0, { '.' },
36};
37const struct cpu_str NAME_BITMAP = {
38 7, 0, { '$', 'B', 'i', 't', 'm', 'a', 'p' },
39};
40const struct cpu_str NAME_BOOT = {
41 5, 0, { '$', 'B', 'o', 'o', 't' },
42};
43const struct cpu_str NAME_BADCLUS = {
44 8, 0, { '$', 'B', 'a', 'd', 'C', 'l', 'u', 's' },
45};
46const struct cpu_str NAME_QUOTA = {
47 6, 0, { '$', 'Q', 'u', 'o', 't', 'a' },
48};
49const struct cpu_str NAME_SECURE = {
50 7, 0, { '$', 'S', 'e', 'c', 'u', 'r', 'e' },
51};
52const struct cpu_str NAME_UPCASE = {
53 7, 0, { '$', 'U', 'p', 'C', 'a', 's', 'e' },
54};
55const struct cpu_str NAME_EXTEND = {
56 7, 0, { '$', 'E', 'x', 't', 'e', 'n', 'd' },
57};
58const struct cpu_str NAME_OBJID = {
59 6, 0, { '$', 'O', 'b', 'j', 'I', 'd' },
60};
61const struct cpu_str NAME_REPARSE = {
62 8, 0, { '$', 'R', 'e', 'p', 'a', 'r', 's', 'e' },
63};
64const struct cpu_str NAME_USNJRNL = {
65 8, 0, { '$', 'U', 's', 'n', 'J', 'r', 'n', 'l' },
66};
67const __le16 BAD_NAME[4] = {
68 cpu_to_le16('$'), cpu_to_le16('B'), cpu_to_le16('a'), cpu_to_le16('d'),
69};
70const __le16 I30_NAME[4] = {
71 cpu_to_le16('$'), cpu_to_le16('I'), cpu_to_le16('3'), cpu_to_le16('0'),
72};
73const __le16 SII_NAME[4] = {
74 cpu_to_le16('$'), cpu_to_le16('S'), cpu_to_le16('I'), cpu_to_le16('I'),
75};
76const __le16 SDH_NAME[4] = {
77 cpu_to_le16('$'), cpu_to_le16('S'), cpu_to_le16('D'), cpu_to_le16('H'),
78};
79const __le16 SDS_NAME[4] = {
80 cpu_to_le16('$'), cpu_to_le16('S'), cpu_to_le16('D'), cpu_to_le16('S'),
81};
82const __le16 SO_NAME[2] = {
83 cpu_to_le16('$'), cpu_to_le16('O'),
84};
85const __le16 SQ_NAME[2] = {
86 cpu_to_le16('$'), cpu_to_le16('Q'),
87};
88const __le16 SR_NAME[2] = {
89 cpu_to_le16('$'), cpu_to_le16('R'),
90};
91
92#ifdef CONFIG_NTFS3_LZX_XPRESS
93const __le16 WOF_NAME[17] = {
94 cpu_to_le16('W'), cpu_to_le16('o'), cpu_to_le16('f'), cpu_to_le16('C'),
95 cpu_to_le16('o'), cpu_to_le16('m'), cpu_to_le16('p'), cpu_to_le16('r'),
96 cpu_to_le16('e'), cpu_to_le16('s'), cpu_to_le16('s'), cpu_to_le16('e'),
97 cpu_to_le16('d'), cpu_to_le16('D'), cpu_to_le16('a'), cpu_to_le16('t'),
98 cpu_to_le16('a'),
99};
100#endif
101
1d07a9df
DP		 102static const __le16 CON_NAME[3] = {
103 cpu_to_le16('C'), cpu_to_le16('O'), cpu_to_le16('N'),
104};
105
106static const __le16 NUL_NAME[3] = {
107 cpu_to_le16('N'), cpu_to_le16('U'), cpu_to_le16('L'),
108};
109
110static const __le16 AUX_NAME[3] = {
111 cpu_to_le16('A'), cpu_to_le16('U'), cpu_to_le16('X'),
112};
113
114static const __le16 PRN_NAME[3] = {
115 cpu_to_le16('P'), cpu_to_le16('R'), cpu_to_le16('N'),
116};
117
118static const __le16 COM_NAME[3] = {
119 cpu_to_le16('C'), cpu_to_le16('O'), cpu_to_le16('M'),
120};
121
122static const __le16 LPT_NAME[3] = {
123 cpu_to_le16('L'), cpu_to_le16('P'), cpu_to_le16('T'),
124};
125
82cae269
KK		 126// clang-format on
127
128/*
e8b8e97f 129 * ntfs_fix_pre_write - Insert fixups into @rhdr before writing to disk.
82cae269
KK		 130 */
131bool ntfs_fix_pre_write(struct NTFS_RECORD_HEADER *rhdr, size_t bytes)
132{
133 u16 *fixup, *ptr;
134 u16 sample;
135 u16 fo = le16_to_cpu(rhdr->fix_off);
136 u16 fn = le16_to_cpu(rhdr->fix_num);
137
138 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- ||
139 fn * SECTOR_SIZE > bytes) {
140 return false;
141 }
142
e8b8e97f 143 /* Get fixup pointer. */
82cae269
KK		 144 fixup = Add2Ptr(rhdr, fo);
145
146 if (*fixup >= 0x7FFF)
147 *fixup = 1;
148 else
149 *fixup += 1;
150
151 sample = *fixup;
152
153 ptr = Add2Ptr(rhdr, SECTOR_SIZE - sizeof(short));
154
155 while (fn--) {
156 *++fixup = *ptr;
157 *ptr = sample;
158 ptr += SECTOR_SIZE / sizeof(short);
159 }
160 return true;
161}
162
163/*
e8b8e97f 164 * ntfs_fix_post_read - Remove fixups after reading from disk.
82cae269 165 *
e8b8e97f 166 * Return: < 0 if error, 0 if ok, 1 if need to update fixups.
82cae269
KK		 167 */
168int ntfs_fix_post_read(struct NTFS_RECORD_HEADER *rhdr, size_t bytes,
169 bool simple)
170{
171 int ret;
172 u16 *fixup, *ptr;
173 u16 sample, fo, fn;
174
175 fo = le16_to_cpu(rhdr->fix_off);
96de65a9 176 fn = simple ? ((bytes >> SECTOR_SHIFT) + 1) :
f0377761 177 le16_to_cpu(rhdr->fix_num);
82cae269 178
e8b8e97f 179 /* Check errors. */
82cae269
KK		 180 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- ||
181 fn * SECTOR_SIZE > bytes) {
e0f363a9 182 return -E_NTFS_CORRUPT;
82cae269
KK		 183 }
184
e8b8e97f 185 /* Get fixup pointer. */
82cae269
KK		 186 fixup = Add2Ptr(rhdr, fo);
187 sample = *fixup;
188 ptr = Add2Ptr(rhdr, SECTOR_SIZE - sizeof(short));
189 ret = 0;
190
191 while (fn--) {
e8b8e97f 192 /* Test current word. */
82cae269
KK		 193 if (*ptr != sample) {
194 /* Fixup does not match! Is it serious error? */
195 ret = -E_NTFS_FIXUP;
196 }
197
e8b8e97f 198 /* Replace fixup. */
82cae269
KK		 199 *ptr = *++fixup;
200 ptr += SECTOR_SIZE / sizeof(short);
201 }
202
203 return ret;
204}
205
206/*
e8b8e97f 207 * ntfs_extend_init - Load $Extend file.
82cae269
KK		 208 */
209int ntfs_extend_init(struct ntfs_sb_info *sbi)
210{
211 int err;
212 struct super_block *sb = sbi->sb;
213 struct inode *inode, *inode2;
214 struct MFT_REF ref;
215
216 if (sbi->volume.major_ver < 3) {
217 ntfs_notice(sb, "Skip $Extend 'cause NTFS version");
218 return 0;
219 }
220
221 ref.low = cpu_to_le32(MFT_REC_EXTEND);
222 ref.high = 0;
223 ref.seq = cpu_to_le16(MFT_REC_EXTEND);
224 inode = ntfs_iget5(sb, &ref, &NAME_EXTEND);
225 if (IS_ERR(inode)) {
226 err = PTR_ERR(inode);
e43f6ec2 227 ntfs_err(sb, "Failed to load $Extend (%d).", err);
82cae269
KK		 228 inode = NULL;
229 goto out;
230 }
231
e8b8e97f 232 /* If ntfs_iget5() reads from disk it never returns bad inode. */
82cae269
KK		 233 if (!S_ISDIR(inode->i_mode)) {
234 err = -EINVAL;
235 goto out;
236 }
237
238 /* Try to find $ObjId */
239 inode2 = dir_search_u(inode, &NAME_OBJID, NULL);
240 if (inode2 && !IS_ERR(inode2)) {
241 if (is_bad_inode(inode2)) {
242 iput(inode2);
243 } else {
244 sbi->objid.ni = ntfs_i(inode2);
245 sbi->objid_no = inode2->i_ino;
246 }
247 }
248
249 /* Try to find $Quota */
250 inode2 = dir_search_u(inode, &NAME_QUOTA, NULL);
251 if (inode2 && !IS_ERR(inode2)) {
252 sbi->quota_no = inode2->i_ino;
253 iput(inode2);
254 }
255
256 /* Try to find $Reparse */
257 inode2 = dir_search_u(inode, &NAME_REPARSE, NULL);
258 if (inode2 && !IS_ERR(inode2)) {
259 sbi->reparse.ni = ntfs_i(inode2);
260 sbi->reparse_no = inode2->i_ino;
261 }
262
263 /* Try to find $UsnJrnl */
264 inode2 = dir_search_u(inode, &NAME_USNJRNL, NULL);
265 if (inode2 && !IS_ERR(inode2)) {
266 sbi->usn_jrnl_no = inode2->i_ino;
267 iput(inode2);
268 }
269
270 err = 0;
271out:
272 iput(inode);
273 return err;
274}
275
276int ntfs_loadlog_and_replay(struct ntfs_inode *ni, struct ntfs_sb_info *sbi)
277{
278 int err = 0;
279 struct super_block *sb = sbi->sb;
280 bool initialized = false;
281 struct MFT_REF ref;
282 struct inode *inode;
283
e8b8e97f 284 /* Check for 4GB. */
82cae269 285 if (ni->vfs_inode.i_size >= 0x100000000ull) {
e43f6ec2 286 ntfs_err(sb, "\x24LogFile is large than 4G.");
82cae269
KK		 287 err = -EINVAL;
288 goto out;
289 }
290
291 sbi->flags |= NTFS_FLAGS_LOG_REPLAYING;
292
293 ref.low = cpu_to_le32(MFT_REC_MFT);
294 ref.high = 0;
295 ref.seq = cpu_to_le16(1);
296
297 inode = ntfs_iget5(sb, &ref, NULL);
298
299 if (IS_ERR(inode))
300 inode = NULL;
301
302 if (!inode) {
e8b8e97f 303 /* Try to use MFT copy. */
82cae269
KK		 304 u64 t64 = sbi->mft.lbo;
305
306 sbi->mft.lbo = sbi->mft.lbo2;
307 inode = ntfs_iget5(sb, &ref, NULL);
308 sbi->mft.lbo = t64;
309 if (IS_ERR(inode))
310 inode = NULL;
311 }
312
313 if (!inode) {
314 err = -EINVAL;
315 ntfs_err(sb, "Failed to load $MFT.");
316 goto out;
317 }
318
319 sbi->mft.ni = ntfs_i(inode);
320
e8b8e97f 321 /* LogFile should not contains attribute list. */
82cae269
KK		 322 err = ni_load_all_mi(sbi->mft.ni);
323 if (!err)
324 err = log_replay(ni, &initialized);
325
326 iput(inode);
327 sbi->mft.ni = NULL;
328
329 sync_blockdev(sb->s_bdev);
330 invalidate_bdev(sb->s_bdev);
331
332 if (sbi->flags & NTFS_FLAGS_NEED_REPLAY) {
333 err = 0;
334 goto out;
335 }
336
337 if (sb_rdonly(sb) || !initialized)
338 goto out;
339
d3624466 340 /* Fill LogFile by '-1' if it is initialized. */
82cae269
KK		 341 err = ntfs_bio_fill_1(sbi, &ni->file.run);
342
343out:
344 sbi->flags &= ~NTFS_FLAGS_LOG_REPLAYING;
345
346 return err;
347}
348
82cae269 349/*
e8b8e97f 350 * ntfs_look_for_free_space - Look for a free space in bitmap.
82cae269
KK		 351 */
352int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len,
353 CLST *new_lcn, CLST *new_len,
354 enum ALLOCATE_OPT opt)
355{
356 int err;
edb853ff 357 CLST alen;
82cae269 358 struct super_block *sb = sbi->sb;
78ab59fe 359 size_t alcn, zlen, zeroes, zlcn, zlen2, ztrim, new_zlen;
82cae269
KK		 360 struct wnd_bitmap *wnd = &sbi->used.bitmap;
361
362 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS);
363 if (opt & ALLOCATE_MFT) {
82cae269
KK		 364 zlen = wnd_zone_len(wnd);
365
366 if (!zlen) {
367 err = ntfs_refresh_zone(sbi);
368 if (err)
edb853ff
KA		 369 goto up_write;
370
82cae269 371 zlen = wnd_zone_len(wnd);
78ab59fe 372 }
82cae269 373
78ab59fe
KK		 374 if (!zlen) {
375 ntfs_err(sbi->sb, "no free space to extend mft");
edb853ff
KA		 376 err = -ENOSPC;
377 goto up_write;
82cae269
KK		 378 }
379
380 lcn = wnd_zone_bit(wnd);
6e3331ee 381 alen = min_t(CLST, len, zlen);
82cae269
KK		 382
383 wnd_zone_set(wnd, lcn + alen, zlen - alen);
384
385 err = wnd_set_used(wnd, lcn, alen);
edb853ff
KA		 386 if (err)
387 goto up_write;
388
78ab59fe 389 alcn = lcn;
edb853ff 390 goto space_found;
82cae269 391 }
82cae269
KK		 392 /*
393 * 'Cause cluster 0 is always used this value means that we should use
e8b8e97f 394 * cached value of 'next_free_lcn' to improve performance.
82cae269
KK		 395 */
396 if (!lcn)
397 lcn = sbi->used.next_free_lcn;
398
399 if (lcn >= wnd->nbits)
400 lcn = 0;
401
78ab59fe
KK		 402 alen = wnd_find(wnd, len, lcn, BITMAP_FIND_MARK_AS_USED, &alcn);
403 if (alen)
edb853ff 404 goto space_found;
82cae269 405
e8b8e97f 406 /* Try to use clusters from MftZone. */
82cae269
KK		 407 zlen = wnd_zone_len(wnd);
408 zeroes = wnd_zeroes(wnd);
409
78ab59fe 410 /* Check too big request */
edb853ff
KA		 411 if (len > zeroes + zlen || zlen <= NTFS_MIN_MFT_ZONE) {
412 err = -ENOSPC;
413 goto up_write;
414 }
82cae269 415
e8b8e97f 416 /* How many clusters to cat from zone. */
82cae269
KK		 417 zlcn = wnd_zone_bit(wnd);
418 zlen2 = zlen >> 1;
b5322eb1
KA		 419 ztrim = clamp_val(len, zlen2, zlen);
420 new_zlen = max_t(size_t, zlen - ztrim, NTFS_MIN_MFT_ZONE);
82cae269
KK		 421
422 wnd_zone_set(wnd, zlcn, new_zlen);
423
e8b8e97f 424 /* Allocate continues clusters. */
78ab59fe
KK		 425 alen = wnd_find(wnd, len, 0,
426 BITMAP_FIND_MARK_AS_USED | BITMAP_FIND_FULL, &alcn);
edb853ff 427 if (!alen) {
78ab59fe 428 err = -ENOSPC;
edb853ff 429 goto up_write;
78ab59fe 430 }
82cae269 431
edb853ff
KA		 432space_found:
433 err = 0;
434 *new_len = alen;
435 *new_lcn = alcn;
436
437 ntfs_unmap_meta(sb, alcn, alen);
438
439 /* Set hint for next requests. */
440 if (!(opt & ALLOCATE_MFT))
441 sbi->used.next_free_lcn = alcn + alen;
442up_write:
82cae269
KK		 443 up_write(&wnd->rw_lock);
444 return err;
445}
446
910013f7
KK		 447/*
448 * ntfs_check_for_free_space
449 *
450 * Check if it is possible to allocate 'clen' clusters and 'mlen' Mft records
451 */
452bool ntfs_check_for_free_space(struct ntfs_sb_info *sbi, CLST clen, CLST mlen)
453{
454 size_t free, zlen, avail;
455 struct wnd_bitmap *wnd;
456
457 wnd = &sbi->used.bitmap;
458 down_read_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS);
459 free = wnd_zeroes(wnd);
6f80ed14 460 zlen = min_t(size_t, NTFS_MIN_MFT_ZONE, wnd_zone_len(wnd));
910013f7
KK		 461 up_read(&wnd->rw_lock);
462
463 if (free < zlen + clen)
464 return false;
465
466 avail = free - (zlen + clen);
467
468 wnd = &sbi->mft.bitmap;
469 down_read_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT);
470 free = wnd_zeroes(wnd);
471 zlen = wnd_zone_len(wnd);
472 up_read(&wnd->rw_lock);
473
474 if (free >= zlen + mlen)
475 return true;
476
477 return avail >= bytes_to_cluster(sbi, mlen << sbi->record_bits);
478}
479
82cae269 480/*
e8b8e97f 481 * ntfs_extend_mft - Allocate additional MFT records.
82cae269 482 *
e8b8e97f 483 * sbi->mft.bitmap is locked for write.
82cae269
KK		 484 *
485 * NOTE: recursive:
486 * ntfs_look_free_mft ->
487 * ntfs_extend_mft ->
488 * attr_set_size ->
489 * ni_insert_nonresident ->
490 * ni_insert_attr ->
491 * ni_ins_attr_ext ->
492 * ntfs_look_free_mft ->
493 * ntfs_extend_mft
e8b8e97f
KA		 494 *
495 * To avoid recursive always allocate space for two new MFT records
496 * see attrib.c: "at least two MFT to avoid recursive loop".
82cae269
KK		 497 */
498static int ntfs_extend_mft(struct ntfs_sb_info *sbi)
499{
500 int err;
501 struct ntfs_inode *ni = sbi->mft.ni;
502 size_t new_mft_total;
503 u64 new_mft_bytes, new_bitmap_bytes;
504 struct ATTRIB *attr;
505 struct wnd_bitmap *wnd = &sbi->mft.bitmap;
506
97a6815e 507 new_mft_total = ALIGN(wnd->nbits + NTFS_MFT_INCREASE_STEP, 128);
82cae269
KK		 508 new_mft_bytes = (u64)new_mft_total << sbi->record_bits;
509
e8b8e97f 510 /* Step 1: Resize $MFT::DATA. */
82cae269
KK		 511 down_write(&ni->file.run_lock);
512 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run,
513 new_mft_bytes, NULL, false, &attr);
514
515 if (err) {
516 up_write(&ni->file.run_lock);
517 goto out;
518 }
519
520 attr->nres.valid_size = attr->nres.data_size;
521 new_mft_total = le64_to_cpu(attr->nres.alloc_size) >> sbi->record_bits;
522 ni->mi.dirty = true;
523
e8b8e97f 524 /* Step 2: Resize $MFT::BITMAP. */
82cae269
KK		 525 new_bitmap_bytes = bitmap_size(new_mft_total);
526
527 err = attr_set_size(ni, ATTR_BITMAP, NULL, 0, &sbi->mft.bitmap.run,
528 new_bitmap_bytes, &new_bitmap_bytes, true, NULL);
529
e8b8e97f 530 /* Refresh MFT Zone if necessary. */
82cae269
KK		 531 down_write_nested(&sbi->used.bitmap.rw_lock, BITMAP_MUTEX_CLUSTERS);
532
533 ntfs_refresh_zone(sbi);
534
535 up_write(&sbi->used.bitmap.rw_lock);
536 up_write(&ni->file.run_lock);
537
538 if (err)
539 goto out;
540
541 err = wnd_extend(wnd, new_mft_total);
542
543 if (err)
544 goto out;
545
546 ntfs_clear_mft_tail(sbi, sbi->mft.used, new_mft_total);
547
548 err = _ni_write_inode(&ni->vfs_inode, 0);
549out:
550 return err;
551}
552
553/*
e8b8e97f 554 * ntfs_look_free_mft - Look for a free MFT record.
82cae269
KK		 555 */
556int ntfs_look_free_mft(struct ntfs_sb_info *sbi, CLST *rno, bool mft,
557 struct ntfs_inode *ni, struct mft_inode **mi)
558{
559 int err = 0;
560 size_t zbit, zlen, from, to, fr;
561 size_t mft_total;
562 struct MFT_REF ref;
563 struct super_block *sb = sbi->sb;
564 struct wnd_bitmap *wnd = &sbi->mft.bitmap;
565 u32 ir;
566
567 static_assert(sizeof(sbi->mft.reserved_bitmap) * 8 >=
568 MFT_REC_FREE - MFT_REC_RESERVED);
569
570 if (!mft)
571 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT);
572
573 zlen = wnd_zone_len(wnd);
574
e8b8e97f 575 /* Always reserve space for MFT. */
82cae269
KK		 576 if (zlen) {
577 if (mft) {
578 zbit = wnd_zone_bit(wnd);
579 *rno = zbit;
580 wnd_zone_set(wnd, zbit + 1, zlen - 1);
581 }
582 goto found;
583 }
584
e8b8e97f 585 /* No MFT zone. Find the nearest to '0' free MFT. */
82cae269
KK		 586 if (!wnd_find(wnd, 1, MFT_REC_FREE, 0, &zbit)) {
587 /* Resize MFT */
588 mft_total = wnd->nbits;
589
590 err = ntfs_extend_mft(sbi);
591 if (!err) {
592 zbit = mft_total;
593 goto reserve_mft;
594 }
595
596 if (!mft || MFT_REC_FREE == sbi->mft.next_reserved)
597 goto out;
598
599 err = 0;
600
601 /*
602 * Look for free record reserved area [11-16) ==
603 * [MFT_REC_RESERVED, MFT_REC_FREE ) MFT bitmap always
e8b8e97f 604 * marks it as used.
82cae269
KK		 605 */
606 if (!sbi->mft.reserved_bitmap) {
e8b8e97f 607 /* Once per session create internal bitmap for 5 bits. */
82cae269
KK		 608 sbi->mft.reserved_bitmap = 0xFF;
609
610 ref.high = 0;
611 for (ir = MFT_REC_RESERVED; ir < MFT_REC_FREE; ir++) {
612 struct inode *i;
613 struct ntfs_inode *ni;
614 struct MFT_REC *mrec;
615
616 ref.low = cpu_to_le32(ir);
617 ref.seq = cpu_to_le16(ir);
618
619 i = ntfs_iget5(sb, &ref, NULL);
620 if (IS_ERR(i)) {
621next:
622 ntfs_notice(
623 sb,
624 "Invalid reserved record %x",
625 ref.low);
626 continue;
627 }
628 if (is_bad_inode(i)) {
629 iput(i);
630 goto next;
631 }
632
633 ni = ntfs_i(i);
634
635 mrec = ni->mi.mrec;
636
637 if (!is_rec_base(mrec))
638 goto next;
639
640 if (mrec->hard_links)
641 goto next;
642
643 if (!ni_std(ni))
644 goto next;
645
646 if (ni_find_attr(ni, NULL, NULL, ATTR_NAME,
647 NULL, 0, NULL, NULL))
648 goto next;
649
e483783c 650 __clear_bit(ir - MFT_REC_RESERVED,
82cae269
KK		 651 &sbi->mft.reserved_bitmap);
652 }
653 }
654
655 /* Scan 5 bits for zero. Bit 0 == MFT_REC_RESERVED */
e483783c 656 zbit = find_next_zero_bit(&sbi->mft.reserved_bitmap,
82cae269
KK		 657 MFT_REC_FREE, MFT_REC_RESERVED);
658 if (zbit >= MFT_REC_FREE) {
659 sbi->mft.next_reserved = MFT_REC_FREE;
660 goto out;
661 }
662
663 zlen = 1;
664 sbi->mft.next_reserved = zbit;
665 } else {
666reserve_mft:
667 zlen = zbit == MFT_REC_FREE ? (MFT_REC_USER - MFT_REC_FREE) : 4;
668 if (zbit + zlen > wnd->nbits)
669 zlen = wnd->nbits - zbit;
670
671 while (zlen > 1 && !wnd_is_free(wnd, zbit, zlen))
672 zlen -= 1;
673
e8b8e97f 674 /* [zbit, zbit + zlen) will be used for MFT itself. */
82cae269
KK		 675 from = sbi->mft.used;
676 if (from < zbit)
677 from = zbit;
678 to = zbit + zlen;
679 if (from < to) {
680 ntfs_clear_mft_tail(sbi, from, to);
681 sbi->mft.used = to;
682 }
683 }
684
685 if (mft) {
686 *rno = zbit;
687 zbit += 1;
688 zlen -= 1;
689 }
690
691 wnd_zone_set(wnd, zbit, zlen);
692
693found:
694 if (!mft) {
e8b8e97f 695 /* The request to get record for general purpose. */
82cae269
KK		 696 if (sbi->mft.next_free < MFT_REC_USER)
697 sbi->mft.next_free = MFT_REC_USER;
698
699 for (;;) {
700 if (sbi->mft.next_free >= sbi->mft.bitmap.nbits) {
701 } else if (!wnd_find(wnd, 1, MFT_REC_USER, 0, &fr)) {
702 sbi->mft.next_free = sbi->mft.bitmap.nbits;
703 } else {
704 *rno = fr;
705 sbi->mft.next_free = *rno + 1;
706 break;
707 }
708
709 err = ntfs_extend_mft(sbi);
710 if (err)
711 goto out;
712 }
713 }
714
715 if (ni && !ni_add_subrecord(ni, *rno, mi)) {
716 err = -ENOMEM;
717 goto out;
718 }
719
e8b8e97f 720 /* We have found a record that are not reserved for next MFT. */
82cae269
KK		 721 if (*rno >= MFT_REC_FREE)
722 wnd_set_used(wnd, *rno, 1);
723 else if (*rno >= MFT_REC_RESERVED && sbi->mft.reserved_bitmap_inited)
e483783c 724 __set_bit(*rno - MFT_REC_RESERVED, &sbi->mft.reserved_bitmap);
82cae269
KK		 725
726out:
727 if (!mft)
728 up_write(&wnd->rw_lock);
729
730 return err;
731}
732
733/*
e8b8e97f 734 * ntfs_mark_rec_free - Mark record as free.
071100ea 735 * is_mft - true if we are changing MFT
82cae269 736 */
071100ea 737void ntfs_mark_rec_free(struct ntfs_sb_info *sbi, CLST rno, bool is_mft)
82cae269
KK		 738{
739 struct wnd_bitmap *wnd = &sbi->mft.bitmap;
740
071100ea
KK		 741 if (!is_mft)
742 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT);
82cae269
KK		 743 if (rno >= wnd->nbits)
744 goto out;
745
746 if (rno >= MFT_REC_FREE) {
747 if (!wnd_is_used(wnd, rno, 1))
748 ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
749 else
750 wnd_set_free(wnd, rno, 1);
751 } else if (rno >= MFT_REC_RESERVED && sbi->mft.reserved_bitmap_inited) {
e483783c 752 __clear_bit(rno - MFT_REC_RESERVED, &sbi->mft.reserved_bitmap);
82cae269
KK		 753 }
754
755 if (rno < wnd_zone_bit(wnd))
756 wnd_zone_set(wnd, rno, 1);
757 else if (rno < sbi->mft.next_free && rno >= MFT_REC_USER)
758 sbi->mft.next_free = rno;
759
760out:
071100ea
KK		 761 if (!is_mft)
762 up_write(&wnd->rw_lock);
82cae269
KK		 763}
764
765/*
e8b8e97f 766 * ntfs_clear_mft_tail - Format empty records [from, to).
82cae269 767 *
e8b8e97f 768 * sbi->mft.bitmap is locked for write.
82cae269
KK		 769 */
770int ntfs_clear_mft_tail(struct ntfs_sb_info *sbi, size_t from, size_t to)
771{
772 int err;
773 u32 rs;
774 u64 vbo;
775 struct runs_tree *run;
776 struct ntfs_inode *ni;
777
778 if (from >= to)
779 return 0;
780
781 rs = sbi->record_size;
782 ni = sbi->mft.ni;
783 run = &ni->file.run;
784
785 down_read(&ni->file.run_lock);
786 vbo = (u64)from * rs;
787 for (; from < to; from++, vbo += rs) {
788 struct ntfs_buffers nb;
789
790 err = ntfs_get_bh(sbi, run, vbo, rs, &nb);
791 if (err)
792 goto out;
793
794 err = ntfs_write_bh(sbi, &sbi->new_rec->rhdr, &nb, 0);
795 nb_put(&nb);
796 if (err)
797 goto out;
798 }
799
800out:
801 sbi->mft.used = from;
802 up_read(&ni->file.run_lock);
803 return err;
804}
805
806/*
e8b8e97f 807 * ntfs_refresh_zone - Refresh MFT zone.
82cae269 808 *
e8b8e97f
KA		 809 * sbi->used.bitmap is locked for rw.
810 * sbi->mft.bitmap is locked for write.
811 * sbi->mft.ni->file.run_lock for write.
82cae269
KK		 812 */
813int ntfs_refresh_zone(struct ntfs_sb_info *sbi)
814{
8335ebe1 815 CLST lcn, vcn, len;
82cae269
KK		 816 size_t lcn_s, zlen;
817 struct wnd_bitmap *wnd = &sbi->used.bitmap;
818 struct ntfs_inode *ni = sbi->mft.ni;
819
e8b8e97f 820 /* Do not change anything unless we have non empty MFT zone. */
82cae269
KK		 821 if (wnd_zone_len(wnd))
822 return 0;
823
82cae269
KK		 824 vcn = bytes_to_cluster(sbi,
825 (u64)sbi->mft.bitmap.nbits << sbi->record_bits);
826
827 if (!run_lookup_entry(&ni->file.run, vcn - 1, &lcn, &len, NULL))
828 lcn = SPARSE_LCN;
829
e8b8e97f 830 /* We should always find Last Lcn for MFT. */
82cae269
KK		 831 if (lcn == SPARSE_LCN)
832 return -EINVAL;
833
834 lcn_s = lcn + 1;
835
e8b8e97f 836 /* Try to allocate clusters after last MFT run. */
8335ebe1 837 zlen = wnd_find(wnd, sbi->zone_max, lcn_s, 0, &lcn_s);
82cae269
KK		 838 wnd_zone_set(wnd, lcn_s, zlen);
839
840 return 0;
841}
842
843/*
e8b8e97f 844 * ntfs_update_mftmirr - Update $MFTMirr data.
82cae269 845 */
e66af07c 846void ntfs_update_mftmirr(struct ntfs_sb_info *sbi, int wait)
82cae269
KK		 847{
848 int err;
849 struct super_block *sb = sbi->sb;
e483783c 850 u32 blocksize, bytes;
82cae269 851 sector_t block1, block2;
82cae269 852
96de65a9
KK		 853 /*
854 * sb can be NULL here. In this case sbi->flags should be 0 too.
855 */
856 if (!sb || !(sbi->flags & NTFS_FLAGS_MFTMIRR))
e66af07c 857 return;
321460ca
PS		 858
859 blocksize = sb->s_blocksize;
82cae269
KK		 860 bytes = sbi->mft.recs_mirr << sbi->record_bits;
861 block1 = sbi->mft.lbo >> sb->s_blocksize_bits;
862 block2 = sbi->mft.lbo2 >> sb->s_blocksize_bits;
863
864 for (; bytes >= blocksize; bytes -= blocksize) {
865 struct buffer_head *bh1, *bh2;
866
867 bh1 = sb_bread(sb, block1++);
e66af07c
PS		 868 if (!bh1)
869 return;
82cae269
KK		 870
871 bh2 = sb_getblk(sb, block2++);
872 if (!bh2) {
873 put_bh(bh1);
e66af07c 874 return;
82cae269
KK		 875 }
876
877 if (buffer_locked(bh2))
878 __wait_on_buffer(bh2);
879
880 lock_buffer(bh2);
881 memcpy(bh2->b_data, bh1->b_data, blocksize);
882 set_buffer_uptodate(bh2);
883 mark_buffer_dirty(bh2);
884 unlock_buffer(bh2);
885
886 put_bh(bh1);
887 bh1 = NULL;
888
ba118928 889 err = wait ? sync_dirty_buffer(bh2) : 0;
82cae269
KK		 890
891 put_bh(bh2);
892 if (err)
e66af07c 893 return;
82cae269
KK		 894 }
895
896 sbi->flags &= ~NTFS_FLAGS_MFTMIRR;
82cae269 897}
82cae269 898
c12df45e
KK		 899/*
900 * ntfs_bad_inode
901 *
902 * Marks inode as bad and marks fs as 'dirty'
903 */
904void ntfs_bad_inode(struct inode *inode, const char *hint)
905{
906 struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
907
908 ntfs_inode_err(inode, "%s", hint);
909 make_bad_inode(inode);
910 ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
82cae269
KK		 911}
912
913/*
914 * ntfs_set_state
915 *
e8b8e97f
KA		 916 * Mount: ntfs_set_state(NTFS_DIRTY_DIRTY)
917 * Umount: ntfs_set_state(NTFS_DIRTY_CLEAR)
918 * NTFS error: ntfs_set_state(NTFS_DIRTY_ERROR)
82cae269
KK		 919 */
920int ntfs_set_state(struct ntfs_sb_info *sbi, enum NTFS_DIRTY_FLAGS dirty)
921{
922 int err;
923 struct ATTRIB *attr;
924 struct VOLUME_INFO *info;
925 struct mft_inode *mi;
926 struct ntfs_inode *ni;
62560248 927 __le16 info_flags;
82cae269
KK		 928
929 /*
e8b8e97f
KA		 930 * Do not change state if fs was real_dirty.
931 * Do not change state if fs already dirty(clear).
932 * Do not change any thing if mounted read only.
82cae269
KK		 933 */
934 if (sbi->volume.real_dirty || sb_rdonly(sbi->sb))
935 return 0;
936
e8b8e97f 937 /* Check cached value. */
82cae269
KK		 938 if ((dirty == NTFS_DIRTY_CLEAR ? 0 : VOLUME_FLAG_DIRTY) ==
939 (sbi->volume.flags & VOLUME_FLAG_DIRTY))
940 return 0;
941
942 ni = sbi->volume.ni;
943 if (!ni)
944 return -EINVAL;
945
946 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_DIRTY);
947
948 attr = ni_find_attr(ni, NULL, NULL, ATTR_VOL_INFO, NULL, 0, NULL, &mi);
949 if (!attr) {
950 err = -EINVAL;
951 goto out;
952 }
953
954 info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO);
955 if (!info) {
956 err = -EINVAL;
957 goto out;
958 }
959
62560248
KK		 960 info_flags = info->flags;
961
82cae269
KK		 962 switch (dirty) {
963 case NTFS_DIRTY_ERROR:
964 ntfs_notice(sbi->sb, "Mark volume as dirty due to NTFS errors");
965 sbi->volume.real_dirty = true;
966 fallthrough;
967 case NTFS_DIRTY_DIRTY:
968 info->flags |= VOLUME_FLAG_DIRTY;
969 break;
970 case NTFS_DIRTY_CLEAR:
971 info->flags &= ~VOLUME_FLAG_DIRTY;
972 break;
973 }
e8b8e97f 974 /* Cache current volume flags. */
62560248
KK		 975 if (info_flags != info->flags) {
976 sbi->volume.flags = info->flags;
977 mi->dirty = true;
978 }
82cae269
KK		 979 err = 0;
980
981out:
982 ni_unlock(ni);
983 if (err)
984 return err;
985
06ccfb00 986 mark_inode_dirty_sync(&ni->vfs_inode);
e8b8e97f 987 /* verify(!ntfs_update_mftmirr()); */
82cae269 988
06ccfb00
KK		 989 /* write mft record on disk. */
990 err = _ni_write_inode(&ni->vfs_inode, 1);
82cae269
KK		 991
992 return err;
993}
994
995/*
e8b8e97f 996 * security_hash - Calculates a hash of security descriptor.
82cae269
KK		 997 */
998static inline __le32 security_hash(const void *sd, size_t bytes)
999{
1000 u32 hash = 0;
1001 const __le32 *ptr = sd;
1002
1003 bytes >>= 2;
1004 while (bytes--)
1005 hash = ((hash >> 0x1D) | (hash << 3)) + le32_to_cpu(*ptr++);
1006 return cpu_to_le32(hash);
1007}
1008
1009int ntfs_sb_read(struct super_block *sb, u64 lbo, size_t bytes, void *buffer)
1010{
1011 struct block_device *bdev = sb->s_bdev;
1012 u32 blocksize = sb->s_blocksize;
1013 u64 block = lbo >> sb->s_blocksize_bits;
1014 u32 off = lbo & (blocksize - 1);
1015 u32 op = blocksize - off;
1016
1017 for (; bytes; block += 1, off = 0, op = blocksize) {
1018 struct buffer_head *bh = __bread(bdev, block, blocksize);
1019
1020 if (!bh)
1021 return -EIO;
1022
1023 if (op > bytes)
1024 op = bytes;
1025
1026 memcpy(buffer, bh->b_data + off, op);
1027
1028 put_bh(bh);
1029
1030 bytes -= op;
1031 buffer = Add2Ptr(buffer, op);
1032 }
1033
1034 return 0;
1035}
1036
1037int ntfs_sb_write(struct super_block *sb, u64 lbo, size_t bytes,
1038 const void *buf, int wait)
1039{
1040 u32 blocksize = sb->s_blocksize;
1041 struct block_device *bdev = sb->s_bdev;
1042 sector_t block = lbo >> sb->s_blocksize_bits;
1043 u32 off = lbo & (blocksize - 1);
1044 u32 op = blocksize - off;
1045 struct buffer_head *bh;
1046
1047 if (!wait && (sb->s_flags & SB_SYNCHRONOUS))
1048 wait = 1;
1049
1050 for (; bytes; block += 1, off = 0, op = blocksize) {
1051 if (op > bytes)
1052 op = bytes;
1053
1054 if (op < blocksize) {
1055 bh = __bread(bdev, block, blocksize);
1056 if (!bh) {
1057 ntfs_err(sb, "failed to read block %llx",
1058 (u64)block);
1059 return -EIO;
1060 }
1061 } else {
1062 bh = __getblk(bdev, block, blocksize);
1063 if (!bh)
1064 return -ENOMEM;
1065 }
1066
1067 if (buffer_locked(bh))
1068 __wait_on_buffer(bh);
1069
1070 lock_buffer(bh);
1071 if (buf) {
1072 memcpy(bh->b_data + off, buf, op);
1073 buf = Add2Ptr(buf, op);
1074 } else {
1075 memset(bh->b_data + off, -1, op);
1076 }
1077
1078 set_buffer_uptodate(bh);
1079 mark_buffer_dirty(bh);
1080 unlock_buffer(bh);
1081
1082 if (wait) {
1083 int err = sync_dirty_buffer(bh);
1084
1085 if (err) {
1086 ntfs_err(
1087 sb,
1088 "failed to sync buffer at block %llx, error %d",
1089 (u64)block, err);
1090 put_bh(bh);
1091 return err;
1092 }
1093 }
1094
1095 put_bh(bh);
1096
1097 bytes -= op;
1098 }
1099 return 0;
1100}
1101
1102int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run,
63544672 1103 u64 vbo, const void *buf, size_t bytes, int sync)
82cae269
KK		 1104{
1105 struct super_block *sb = sbi->sb;
1106 u8 cluster_bits = sbi->cluster_bits;
1107 u32 off = vbo & sbi->cluster_mask;
1108 CLST lcn, clen, vcn = vbo >> cluster_bits, vcn_next;
1109 u64 lbo, len;
1110 size_t idx;
1111
1112 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))
1113 return -ENOENT;
1114
1115 if (lcn == SPARSE_LCN)
1116 return -EINVAL;
1117
1118 lbo = ((u64)lcn << cluster_bits) + off;
1119 len = ((u64)clen << cluster_bits) - off;
1120
1121 for (;;) {
6e3331ee 1122 u32 op = min_t(u64, len, bytes);
63544672 1123 int err = ntfs_sb_write(sb, lbo, op, buf, sync);
82cae269
KK		 1124
1125 if (err)
1126 return err;
1127
1128 bytes -= op;
1129 if (!bytes)
1130 break;
1131
1132 vcn_next = vcn + clen;
1133 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||
1134 vcn != vcn_next)
1135 return -ENOENT;
1136
1137 if (lcn == SPARSE_LCN)
1138 return -EINVAL;
1139
1140 if (buf)
1141 buf = Add2Ptr(buf, op);
1142
1143 lbo = ((u64)lcn << cluster_bits);
1144 len = ((u64)clen << cluster_bits);
1145 }
1146
1147 return 0;
1148}
1149
1150struct buffer_head *ntfs_bread_run(struct ntfs_sb_info *sbi,
1151 const struct runs_tree *run, u64 vbo)
1152{
1153 struct super_block *sb = sbi->sb;
1154 u8 cluster_bits = sbi->cluster_bits;
1155 CLST lcn;
1156 u64 lbo;
1157
1158 if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, NULL, NULL))
1159 return ERR_PTR(-ENOENT);
1160
1161 lbo = ((u64)lcn << cluster_bits) + (vbo & sbi->cluster_mask);
1162
1163 return ntfs_bread(sb, lbo >> sb->s_blocksize_bits);
1164}
1165
1166int ntfs_read_run_nb(struct ntfs_sb_info *sbi, const struct runs_tree *run,
1167 u64 vbo, void *buf, u32 bytes, struct ntfs_buffers *nb)
1168{
1169 int err;
1170 struct super_block *sb = sbi->sb;
1171 u32 blocksize = sb->s_blocksize;
1172 u8 cluster_bits = sbi->cluster_bits;
1173 u32 off = vbo & sbi->cluster_mask;
1174 u32 nbh = 0;
1175 CLST vcn_next, vcn = vbo >> cluster_bits;
1176 CLST lcn, clen;
1177 u64 lbo, len;
1178 size_t idx;
1179 struct buffer_head *bh;
1180
1181 if (!run) {
e8b8e97f 1182 /* First reading of $Volume + $MFTMirr + $LogFile goes here. */
82cae269
KK		 1183 if (vbo > MFT_REC_VOL * sbi->record_size) {
1184 err = -ENOENT;
1185 goto out;
1186 }
1187
e8b8e97f 1188 /* Use absolute boot's 'MFTCluster' to read record. */
82cae269
KK		 1189 lbo = vbo + sbi->mft.lbo;
1190 len = sbi->record_size;
1191 } else if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {
1192 err = -ENOENT;
1193 goto out;
1194 } else {
1195 if (lcn == SPARSE_LCN) {
1196 err = -EINVAL;
1197 goto out;
1198 }
1199
1200 lbo = ((u64)lcn << cluster_bits) + off;
1201 len = ((u64)clen << cluster_bits) - off;
1202 }
1203
1204 off = lbo & (blocksize - 1);
1205 if (nb) {
1206 nb->off = off;
1207 nb->bytes = bytes;
1208 }
1209
1210 for (;;) {
1211 u32 len32 = len >= bytes ? bytes : len;
1212 sector_t block = lbo >> sb->s_blocksize_bits;
1213
1214 do {
1215 u32 op = blocksize - off;
1216
1217 if (op > len32)
1218 op = len32;
1219
1220 bh = ntfs_bread(sb, block);
1221 if (!bh) {
1222 err = -EIO;
1223 goto out;
1224 }
1225
1226 if (buf) {
1227 memcpy(buf, bh->b_data + off, op);
1228 buf = Add2Ptr(buf, op);
1229 }
1230
1231 if (!nb) {
1232 put_bh(bh);
1233 } else if (nbh >= ARRAY_SIZE(nb->bh)) {
1234 err = -EINVAL;
1235 goto out;
1236 } else {
1237 nb->bh[nbh++] = bh;
1238 nb->nbufs = nbh;
1239 }
1240
1241 bytes -= op;
1242 if (!bytes)
1243 return 0;
1244 len32 -= op;
1245 block += 1;
1246 off = 0;
1247
1248 } while (len32);
1249
1250 vcn_next = vcn + clen;
1251 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||
1252 vcn != vcn_next) {
1253 err = -ENOENT;
1254 goto out;
1255 }
1256
1257 if (lcn == SPARSE_LCN) {
1258 err = -EINVAL;
1259 goto out;
1260 }
1261
1262 lbo = ((u64)lcn << cluster_bits);
1263 len = ((u64)clen << cluster_bits);
1264 }
1265
1266out:
1267 if (!nbh)
1268 return err;
1269
1270 while (nbh) {
1271 put_bh(nb->bh[--nbh]);
1272 nb->bh[nbh] = NULL;
1273 }
1274
1275 nb->nbufs = 0;
1276 return err;
1277}
1278
e8b8e97f
KA		 1279/*
1280 * ntfs_read_bh
1281 *
1282 * Return: < 0 if error, 0 if ok, -E_NTFS_FIXUP if need to update fixups.
1283 */
82cae269
KK		 1284int ntfs_read_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo,
1285 struct NTFS_RECORD_HEADER *rhdr, u32 bytes,
1286 struct ntfs_buffers *nb)
1287{
1288 int err = ntfs_read_run_nb(sbi, run, vbo, rhdr, bytes, nb);
1289
1290 if (err)
1291 return err;
1292 return ntfs_fix_post_read(rhdr, nb->bytes, true);
1293}
1294
1295int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo,
1296 u32 bytes, struct ntfs_buffers *nb)
1297{
1298 int err = 0;
1299 struct super_block *sb = sbi->sb;
1300 u32 blocksize = sb->s_blocksize;
1301 u8 cluster_bits = sbi->cluster_bits;
1302 CLST vcn_next, vcn = vbo >> cluster_bits;
1303 u32 off;
1304 u32 nbh = 0;
1305 CLST lcn, clen;
1306 u64 lbo, len;
1307 size_t idx;
1308
1309 nb->bytes = bytes;
1310
1311 if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {
1312 err = -ENOENT;
1313 goto out;
1314 }
1315
1316 off = vbo & sbi->cluster_mask;
1317 lbo = ((u64)lcn << cluster_bits) + off;
1318 len = ((u64)clen << cluster_bits) - off;
1319
1320 nb->off = off = lbo & (blocksize - 1);
1321
1322 for (;;) {
6e3331ee 1323 u32 len32 = min_t(u64, len, bytes);
82cae269
KK		 1324 sector_t block = lbo >> sb->s_blocksize_bits;
1325
1326 do {
1327 u32 op;
1328 struct buffer_head *bh;
1329
1330 if (nbh >= ARRAY_SIZE(nb->bh)) {
1331 err = -EINVAL;
1332 goto out;
1333 }
1334
1335 op = blocksize - off;
1336 if (op > len32)
1337 op = len32;
1338
1339 if (op == blocksize) {
1340 bh = sb_getblk(sb, block);
1341 if (!bh) {
1342 err = -ENOMEM;
1343 goto out;
1344 }
1345 if (buffer_locked(bh))
1346 __wait_on_buffer(bh);
1347 set_buffer_uptodate(bh);
1348 } else {
1349 bh = ntfs_bread(sb, block);
1350 if (!bh) {
1351 err = -EIO;
1352 goto out;
1353 }
1354 }
1355
1356 nb->bh[nbh++] = bh;
1357 bytes -= op;
1358 if (!bytes) {
1359 nb->nbufs = nbh;
1360 return 0;
1361 }
1362
1363 block += 1;
1364 len32 -= op;
1365 off = 0;
1366 } while (len32);
1367
1368 vcn_next = vcn + clen;
1369 if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||
1370 vcn != vcn_next) {
1371 err = -ENOENT;
1372 goto out;
1373 }
1374
1375 lbo = ((u64)lcn << cluster_bits);
1376 len = ((u64)clen << cluster_bits);
1377 }
1378
1379out:
1380 while (nbh) {
1381 put_bh(nb->bh[--nbh]);
1382 nb->bh[nbh] = NULL;
1383 }
1384
1385 nb->nbufs = 0;
1386
1387 return err;
1388}
1389
1390int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr,
1391 struct ntfs_buffers *nb, int sync)
1392{
1393 int err = 0;
1394 struct super_block *sb = sbi->sb;
1395 u32 block_size = sb->s_blocksize;
1396 u32 bytes = nb->bytes;
1397 u32 off = nb->off;
1398 u16 fo = le16_to_cpu(rhdr->fix_off);
1399 u16 fn = le16_to_cpu(rhdr->fix_num);
1400 u32 idx;
1401 __le16 *fixup;
1402 __le16 sample;
1403
1404 if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- ||
1405 fn * SECTOR_SIZE > bytes) {
1406 return -EINVAL;
1407 }
1408
1409 for (idx = 0; bytes && idx < nb->nbufs; idx += 1, off = 0) {
1410 u32 op = block_size - off;
1411 char *bh_data;
1412 struct buffer_head *bh = nb->bh[idx];
1413 __le16 *ptr, *end_data;
1414
1415 if (op > bytes)
1416 op = bytes;
1417
1418 if (buffer_locked(bh))
1419 __wait_on_buffer(bh);
1420
8335ebe1 1421 lock_buffer(bh);
82cae269
KK		 1422
1423 bh_data = bh->b_data + off;
1424 end_data = Add2Ptr(bh_data, op);
1425 memcpy(bh_data, rhdr, op);
1426
1427 if (!idx) {
1428 u16 t16;
1429
1430 fixup = Add2Ptr(bh_data, fo);
1431 sample = *fixup;
1432 t16 = le16_to_cpu(sample);
1433 if (t16 >= 0x7FFF) {
1434 sample = *fixup = cpu_to_le16(1);
1435 } else {
1436 sample = cpu_to_le16(t16 + 1);
1437 *fixup = sample;
1438 }
1439
1440 *(__le16 *)Add2Ptr(rhdr, fo) = sample;
1441 }
1442
1443 ptr = Add2Ptr(bh_data, SECTOR_SIZE - sizeof(short));
1444
1445 do {
1446 *++fixup = *ptr;
1447 *ptr = sample;
1448 ptr += SECTOR_SIZE / sizeof(short);
1449 } while (ptr < end_data);
1450
1451 set_buffer_uptodate(bh);
1452 mark_buffer_dirty(bh);
1453 unlock_buffer(bh);
1454
1455 if (sync) {
1456 int err2 = sync_dirty_buffer(bh);
1457
1458 if (!err && err2)
1459 err = err2;
1460 }
1461
1462 bytes -= op;
1463 rhdr = Add2Ptr(rhdr, op);
1464 }
1465
1466 return err;
1467}
1468
e8b8e97f
KA		 1469/*
1470 * ntfs_bio_pages - Read/write pages from/to disk.
1471 */
82cae269
KK		 1472int ntfs_bio_pages(struct ntfs_sb_info *sbi, const struct runs_tree *run,
1473 struct page **pages, u32 nr_pages, u64 vbo, u32 bytes,
ce6b5315 1474 enum req_op op)
82cae269
KK		 1475{
1476 int err = 0;
1477 struct bio *new, *bio = NULL;
1478 struct super_block *sb = sbi->sb;
1479 struct block_device *bdev = sb->s_bdev;
1480 struct page *page;
1481 u8 cluster_bits = sbi->cluster_bits;
1482 CLST lcn, clen, vcn, vcn_next;
1483 u32 add, off, page_idx;
1484 u64 lbo, len;
1485 size_t run_idx;
1486 struct blk_plug plug;
1487
1488 if (!bytes)
1489 return 0;
1490
1491 blk_start_plug(&plug);
1492
e8b8e97f 1493 /* Align vbo and bytes to be 512 bytes aligned. */
82cae269
KK		 1494 lbo = (vbo + bytes + 511) & ~511ull;
1495 vbo = vbo & ~511ull;
1496 bytes = lbo - vbo;
1497
1498 vcn = vbo >> cluster_bits;
1499 if (!run_lookup_entry(run, vcn, &lcn, &clen, &run_idx)) {
1500 err = -ENOENT;
1501 goto out;
1502 }
1503 off = vbo & sbi->cluster_mask;
1504 page_idx = 0;
1505 page = pages[0];
1506
1507 for (;;) {
1508 lbo = ((u64)lcn << cluster_bits) + off;
1509 len = ((u64)clen << cluster_bits) - off;
1510new_bio:
07888c66 1511 new = bio_alloc(bdev, nr_pages - page_idx, op, GFP_NOFS);
82cae269
KK		 1512 if (bio) {
1513 bio_chain(bio, new);
1514 submit_bio(bio);
1515 }
1516 bio = new;
82cae269 1517 bio->bi_iter.bi_sector = lbo >> 9;
82cae269
KK		 1518
1519 while (len) {
1520 off = vbo & (PAGE_SIZE - 1);
1521 add = off + len > PAGE_SIZE ? (PAGE_SIZE - off) : len;
1522
1523 if (bio_add_page(bio, page, add, off) < add)
1524 goto new_bio;
1525
1526 if (bytes <= add)
1527 goto out;
1528 bytes -= add;
1529 vbo += add;
1530
1531 if (add + off == PAGE_SIZE) {
1532 page_idx += 1;
1533 if (WARN_ON(page_idx >= nr_pages)) {
1534 err = -EINVAL;
1535 goto out;
1536 }
1537 page = pages[page_idx];
1538 }
1539
1540 if (len <= add)
1541 break;
1542 len -= add;
1543 lbo += add;
1544 }
1545
1546 vcn_next = vcn + clen;
1547 if (!run_get_entry(run, ++run_idx, &vcn, &lcn, &clen) ||
1548 vcn != vcn_next) {
1549 err = -ENOENT;
1550 goto out;
1551 }
1552 off = 0;
1553 }
1554out:
1555 if (bio) {
1556 if (!err)
1557 err = submit_bio_wait(bio);
1558 bio_put(bio);
1559 }
1560 blk_finish_plug(&plug);
1561
1562 return err;
1563}
1564
1565/*
e8b8e97f
KA		 1566 * ntfs_bio_fill_1 - Helper for ntfs_loadlog_and_replay().
1567 *
1568 * Fill on-disk logfile range by (-1)
1569 * this means empty logfile.
82cae269
KK		 1570 */
1571int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run)
1572{
1573 int err = 0;
1574 struct super_block *sb = sbi->sb;
1575 struct block_device *bdev = sb->s_bdev;
1576 u8 cluster_bits = sbi->cluster_bits;
1577 struct bio *new, *bio = NULL;
1578 CLST lcn, clen;
1579 u64 lbo, len;
1580 size_t run_idx;
1581 struct page *fill;
1582 void *kaddr;
1583 struct blk_plug plug;
1584
1585 fill = alloc_page(GFP_KERNEL);
1586 if (!fill)
1587 return -ENOMEM;
1588
1589 kaddr = kmap_atomic(fill);
1590 memset(kaddr, -1, PAGE_SIZE);
1591 kunmap_atomic(kaddr);
1592 flush_dcache_page(fill);
1593 lock_page(fill);
1594
1595 if (!run_lookup_entry(run, 0, &lcn, &clen, &run_idx)) {
1596 err = -ENOENT;
1597 goto out;
1598 }
1599
1600 /*
e8b8e97f 1601 * TODO: Try blkdev_issue_write_same.
82cae269
KK		 1602 */
1603 blk_start_plug(&plug);
1604 do {
1605 lbo = (u64)lcn << cluster_bits;
1606 len = (u64)clen << cluster_bits;
1607new_bio:
07888c66 1608 new = bio_alloc(bdev, BIO_MAX_VECS, REQ_OP_WRITE, GFP_NOFS);
82cae269
KK		 1609 if (bio) {
1610 bio_chain(bio, new);
1611 submit_bio(bio);
1612 }
1613 bio = new;
82cae269
KK		 1614 bio->bi_iter.bi_sector = lbo >> 9;
1615
1616 for (;;) {
1617 u32 add = len > PAGE_SIZE ? PAGE_SIZE : len;
1618
1619 if (bio_add_page(bio, fill, add, 0) < add)
1620 goto new_bio;
1621
1622 lbo += add;
1623 if (len <= add)
1624 break;
1625 len -= add;
1626 }
1627 } while (run_get_entry(run, ++run_idx, NULL, &lcn, &clen));
1628
365ab499
DC		 1629 if (!err)
1630 err = submit_bio_wait(bio);
1631 bio_put(bio);
1632
82cae269
KK		 1633 blk_finish_plug(&plug);
1634out:
1635 unlock_page(fill);
1636 put_page(fill);
1637
1638 return err;
1639}
1640
1641int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run,
1642 u64 vbo, u64 *lbo, u64 *bytes)
1643{
1644 u32 off;
1645 CLST lcn, len;
1646 u8 cluster_bits = sbi->cluster_bits;
1647
1648 if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &len, NULL))
1649 return -ENOENT;
1650
1651 off = vbo & sbi->cluster_mask;
1652 *lbo = lcn == SPARSE_LCN ? -1 : (((u64)lcn << cluster_bits) + off);
1653 *bytes = ((u64)len << cluster_bits) - off;
1654
1655 return 0;
1656}
1657
a81f47c4
KK		 1658struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST rno,
1659 enum RECORD_FLAG flag)
82cae269
KK		 1660{
1661 int err = 0;
1662 struct super_block *sb = sbi->sb;
1663 struct inode *inode = new_inode(sb);
1664 struct ntfs_inode *ni;
1665
1666 if (!inode)
1667 return ERR_PTR(-ENOMEM);
1668
1669 ni = ntfs_i(inode);
1670
a81f47c4 1671 err = mi_format_new(&ni->mi, sbi, rno, flag, false);
82cae269
KK		 1672 if (err)
1673 goto out;
1674
1675 inode->i_ino = rno;
1676 if (insert_inode_locked(inode) < 0) {
1677 err = -EIO;
1678 goto out;
1679 }
1680
1681out:
1682 if (err) {
db2a3cc6 1683 make_bad_inode(inode);
82cae269
KK		 1684 iput(inode);
1685 ni = ERR_PTR(err);
1686 }
1687 return ni;
1688}
1689
1690/*
1691 * O:BAG:BAD:(A;OICI;FA;;;WD)
e8b8e97f
KA		 1692 * Owner S-1-5-32-544 (Administrators)
1693 * Group S-1-5-32-544 (Administrators)
82cae269
KK		 1694 * ACE: allow S-1-1-0 (Everyone) with FILE_ALL_ACCESS
1695 */
1696const u8 s_default_security[] __aligned(8) = {
1697 0x01, 0x00, 0x04, 0x80, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
1698 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1C, 0x00,
1699 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x14, 0x00, 0xFF, 0x01, 0x1F, 0x00,
1700 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1701 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x20, 0x00, 0x00, 0x00,
1702 0x20, 0x02, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
1703 0x20, 0x00, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00,
1704};
1705
1706static_assert(sizeof(s_default_security) == 0x50);
1707
1708static inline u32 sid_length(const struct SID *sid)
1709{
1710 return struct_size(sid, SubAuthority, sid->SubAuthorityCount);
1711}
1712
1713/*
e8b8e97f
KA		 1714 * is_acl_valid
1715 *
1716 * Thanks Mark Harmstone for idea.
82cae269
KK		 1717 */
1718static bool is_acl_valid(const struct ACL *acl, u32 len)
1719{
1720 const struct ACE_HEADER *ace;
1721 u32 i;
1722 u16 ace_count, ace_size;
1723
1724 if (acl->AclRevision != ACL_REVISION &&
1725 acl->AclRevision != ACL_REVISION_DS) {
1726 /*
1727 * This value should be ACL_REVISION, unless the ACL contains an
1728 * object-specific ACE, in which case this value must be ACL_REVISION_DS.
1729 * All ACEs in an ACL must be at the same revision level.
1730 */
1731 return false;
1732 }
1733
1734 if (acl->Sbz1)
1735 return false;
1736
1737 if (le16_to_cpu(acl->AclSize) > len)
1738 return false;
1739
1740 if (acl->Sbz2)
1741 return false;
1742
1743 len -= sizeof(struct ACL);
1744 ace = (struct ACE_HEADER *)&acl[1];
1745 ace_count = le16_to_cpu(acl->AceCount);
1746
1747 for (i = 0; i < ace_count; i++) {
1748 if (len < sizeof(struct ACE_HEADER))
1749 return false;
1750
1751 ace_size = le16_to_cpu(ace->AceSize);
1752 if (len < ace_size)
1753 return false;
1754
1755 len -= ace_size;
1756 ace = Add2Ptr(ace, ace_size);
1757 }
1758
1759 return true;
1760}
1761
1762bool is_sd_valid(const struct SECURITY_DESCRIPTOR_RELATIVE *sd, u32 len)
1763{
1764 u32 sd_owner, sd_group, sd_sacl, sd_dacl;
1765
1766 if (len < sizeof(struct SECURITY_DESCRIPTOR_RELATIVE))
1767 return false;
1768
1769 if (sd->Revision != 1)
1770 return false;
1771
1772 if (sd->Sbz1)
1773 return false;
1774
1775 if (!(sd->Control & SE_SELF_RELATIVE))
1776 return false;
1777
1778 sd_owner = le32_to_cpu(sd->Owner);
1779 if (sd_owner) {
1780 const struct SID *owner = Add2Ptr(sd, sd_owner);
1781
1782 if (sd_owner + offsetof(struct SID, SubAuthority) > len)
1783 return false;
1784
1785 if (owner->Revision != 1)
1786 return false;
1787
1788 if (sd_owner + sid_length(owner) > len)
1789 return false;
1790 }
1791
1792 sd_group = le32_to_cpu(sd->Group);
1793 if (sd_group) {
1794 const struct SID *group = Add2Ptr(sd, sd_group);
1795
1796 if (sd_group + offsetof(struct SID, SubAuthority) > len)
1797 return false;
1798
1799 if (group->Revision != 1)
1800 return false;
1801
1802 if (sd_group + sid_length(group) > len)
1803 return false;
1804 }
1805
1806 sd_sacl = le32_to_cpu(sd->Sacl);
1807 if (sd_sacl) {
1808 const struct ACL *sacl = Add2Ptr(sd, sd_sacl);
1809
1810 if (sd_sacl + sizeof(struct ACL) > len)
1811 return false;
1812
1813 if (!is_acl_valid(sacl, len - sd_sacl))
1814 return false;
1815 }
1816
1817 sd_dacl = le32_to_cpu(sd->Dacl);
1818 if (sd_dacl) {
1819 const struct ACL *dacl = Add2Ptr(sd, sd_dacl);
1820
1821 if (sd_dacl + sizeof(struct ACL) > len)
1822 return false;
1823
1824 if (!is_acl_valid(dacl, len - sd_dacl))
1825 return false;
1826 }
1827
1828 return true;
1829}
1830
1831/*
e8b8e97f 1832 * ntfs_security_init - Load and parse $Secure.
82cae269
KK		 1833 */
1834int ntfs_security_init(struct ntfs_sb_info *sbi)
1835{
1836 int err;
1837 struct super_block *sb = sbi->sb;
1838 struct inode *inode;
1839 struct ntfs_inode *ni;
1840 struct MFT_REF ref;
1841 struct ATTRIB *attr;
1842 struct ATTR_LIST_ENTRY *le;
1843 u64 sds_size;
8c01308b 1844 size_t off;
82cae269
KK		 1845 struct NTFS_DE *ne;
1846 struct NTFS_DE_SII *sii_e;
1847 struct ntfs_fnd *fnd_sii = NULL;
1848 const struct INDEX_ROOT *root_sii;
1849 const struct INDEX_ROOT *root_sdh;
1850 struct ntfs_index *indx_sdh = &sbi->security.index_sdh;
1851 struct ntfs_index *indx_sii = &sbi->security.index_sii;
1852
1853 ref.low = cpu_to_le32(MFT_REC_SECURE);
1854 ref.high = 0;
1855 ref.seq = cpu_to_le16(MFT_REC_SECURE);
1856
1857 inode = ntfs_iget5(sb, &ref, &NAME_SECURE);
1858 if (IS_ERR(inode)) {
1859 err = PTR_ERR(inode);
e43f6ec2 1860 ntfs_err(sb, "Failed to load $Secure (%d).", err);
82cae269
KK		 1861 inode = NULL;
1862 goto out;
1863 }
1864
1865 ni = ntfs_i(inode);
1866
1867 le = NULL;
1868
1869 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SDH_NAME,
1870 ARRAY_SIZE(SDH_NAME), NULL, NULL);
e43f6ec2
KK		 1871 if (!attr ||
1872 !(root_sdh = resident_data_ex(attr, sizeof(struct INDEX_ROOT))) ||
fc499245 1873 root_sdh->type != ATTR_ZERO ||
bfcdbae0 1874 root_sdh->rule != NTFS_COLLATION_TYPE_SECURITY_HASH ||
fc499245 1875 offsetof(struct INDEX_ROOT, ihdr) +
e43f6ec2
KK		 1876 le32_to_cpu(root_sdh->ihdr.used) >
1877 le32_to_cpu(attr->res.data_size)) {
1878 ntfs_err(sb, "$Secure::$SDH is corrupted.");
82cae269
KK		 1879 err = -EINVAL;
1880 goto out;
1881 }
1882
1883 err = indx_init(indx_sdh, sbi, attr, INDEX_MUTEX_SDH);
e43f6ec2
KK		 1884 if (err) {
1885 ntfs_err(sb, "Failed to initialize $Secure::$SDH (%d).", err);
82cae269 1886 goto out;
e43f6ec2 1887 }
82cae269
KK		 1888
1889 attr = ni_find_attr(ni, attr, &le, ATTR_ROOT, SII_NAME,
1890 ARRAY_SIZE(SII_NAME), NULL, NULL);
e43f6ec2
KK		 1891 if (!attr ||
1892 !(root_sii = resident_data_ex(attr, sizeof(struct INDEX_ROOT))) ||
fc499245 1893 root_sii->type != ATTR_ZERO ||
bfcdbae0 1894 root_sii->rule != NTFS_COLLATION_TYPE_UINT ||
fc499245 1895 offsetof(struct INDEX_ROOT, ihdr) +
e43f6ec2
KK		 1896 le32_to_cpu(root_sii->ihdr.used) >
1897 le32_to_cpu(attr->res.data_size)) {
1898 ntfs_err(sb, "$Secure::$SII is corrupted.");
82cae269
KK		 1899 err = -EINVAL;
1900 goto out;
1901 }
1902
1903 err = indx_init(indx_sii, sbi, attr, INDEX_MUTEX_SII);
e43f6ec2
KK		 1904 if (err) {
1905 ntfs_err(sb, "Failed to initialize $Secure::$SII (%d).", err);
82cae269 1906 goto out;
e43f6ec2 1907 }
82cae269
KK		 1908
1909 fnd_sii = fnd_get();
1910 if (!fnd_sii) {
1911 err = -ENOMEM;
1912 goto out;
1913 }
1914
1915 sds_size = inode->i_size;
1916
e8b8e97f 1917 /* Find the last valid Id. */
82cae269 1918 sbi->security.next_id = SECURITY_ID_FIRST;
e8b8e97f 1919 /* Always write new security at the end of bucket. */
82cae269 1920 sbi->security.next_off =
d3624466 1921 ALIGN(sds_size - SecurityDescriptorsBlockSize, 16);
82cae269 1922
82cae269
KK		 1923 off = 0;
1924 ne = NULL;
1925
1926 for (;;) {
1927 u32 next_id;
1928
1929 err = indx_find_raw(indx_sii, ni, root_sii, &ne, &off, fnd_sii);
1930 if (err || !ne)
1931 break;
1932
1933 sii_e = (struct NTFS_DE_SII *)ne;
a81f47c4 1934 if (le16_to_cpu(ne->view.data_size) < sizeof(sii_e->sec_hdr))
82cae269
KK		 1935 continue;
1936
1937 next_id = le32_to_cpu(sii_e->sec_id) + 1;
1938 if (next_id >= sbi->security.next_id)
1939 sbi->security.next_id = next_id;
82cae269
KK		 1940 }
1941
1942 sbi->security.ni = ni;
1943 inode = NULL;
1944out:
1945 iput(inode);
1946 fnd_put(fnd_sii);
1947
1948 return err;
1949}
1950
1951/*
e8b8e97f 1952 * ntfs_get_security_by_id - Read security descriptor by id.
82cae269
KK		 1953 */
1954int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id,
1955 struct SECURITY_DESCRIPTOR_RELATIVE **sd,
1956 size_t *size)
1957{
1958 int err;
1959 int diff;
1960 struct ntfs_inode *ni = sbi->security.ni;
1961 struct ntfs_index *indx = &sbi->security.index_sii;
1962 void *p = NULL;
1963 struct NTFS_DE_SII *sii_e;
1964 struct ntfs_fnd *fnd_sii;
1965 struct SECURITY_HDR d_security;
1966 const struct INDEX_ROOT *root_sii;
1967 u32 t32;
1968
1969 *sd = NULL;
1970
1971 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY);
1972
1973 fnd_sii = fnd_get();
1974 if (!fnd_sii) {
1975 err = -ENOMEM;
1976 goto out;
1977 }
1978
1979 root_sii = indx_get_root(indx, ni, NULL, NULL);
1980 if (!root_sii) {
1981 err = -EINVAL;
1982 goto out;
1983 }
1984
e8b8e97f 1985 /* Try to find this SECURITY descriptor in SII indexes. */
82cae269
KK		 1986 err = indx_find(indx, ni, root_sii, &security_id, sizeof(security_id),
1987 NULL, &diff, (struct NTFS_DE **)&sii_e, fnd_sii);
1988 if (err)
1989 goto out;
1990
1991 if (diff)
1992 goto out;
1993
1994 t32 = le32_to_cpu(sii_e->sec_hdr.size);
a81f47c4 1995 if (t32 < sizeof(struct SECURITY_HDR)) {
82cae269
KK		 1996 err = -EINVAL;
1997 goto out;
1998 }
1999
a81f47c4 2000 if (t32 > sizeof(struct SECURITY_HDR) + 0x10000) {
e8b8e97f 2001 /* Looks like too big security. 0x10000 - is arbitrary big number. */
82cae269
KK		 2002 err = -EFBIG;
2003 goto out;
2004 }
2005
a81f47c4 2006 *size = t32 - sizeof(struct SECURITY_HDR);
82cae269 2007
195c52bd 2008 p = kmalloc(*size, GFP_NOFS);
82cae269
KK		 2009 if (!p) {
2010 err = -ENOMEM;
2011 goto out;
2012 }
2013
2014 err = ntfs_read_run_nb(sbi, &ni->file.run,
2015 le64_to_cpu(sii_e->sec_hdr.off), &d_security,
2016 sizeof(d_security), NULL);
2017 if (err)
2018 goto out;
2019
a81f47c4 2020 if (memcmp(&d_security, &sii_e->sec_hdr, sizeof(d_security))) {
82cae269
KK		 2021 err = -EINVAL;
2022 goto out;
2023 }
2024
2025 err = ntfs_read_run_nb(sbi, &ni->file.run,
2026 le64_to_cpu(sii_e->sec_hdr.off) +
a81f47c4 2027 sizeof(struct SECURITY_HDR),
82cae269
KK		 2028 p, *size, NULL);
2029 if (err)
2030 goto out;
2031
2032 *sd = p;
2033 p = NULL;
2034
2035out:
195c52bd 2036 kfree(p);
82cae269
KK		 2037 fnd_put(fnd_sii);
2038 ni_unlock(ni);
2039
2040 return err;
2041}
2042
2043/*
e8b8e97f 2044 * ntfs_insert_security - Insert security descriptor into $Secure::SDS.
82cae269
KK		 2045 *
2046 * SECURITY Descriptor Stream data is organized into chunks of 256K bytes
2047 * and it contains a mirror copy of each security descriptor. When writing
2048 * to a security descriptor at location X, another copy will be written at
2049 * location (X+256K).
2050 * When writing a security descriptor that will cross the 256K boundary,
2051 * the pointer will be advanced by 256K to skip
2052 * over the mirror portion.
2053 */
2054int ntfs_insert_security(struct ntfs_sb_info *sbi,
2055 const struct SECURITY_DESCRIPTOR_RELATIVE *sd,
2056 u32 size_sd, __le32 *security_id, bool *inserted)
2057{
2058 int err, diff;
2059 struct ntfs_inode *ni = sbi->security.ni;
2060 struct ntfs_index *indx_sdh = &sbi->security.index_sdh;
2061 struct ntfs_index *indx_sii = &sbi->security.index_sii;
2062 struct NTFS_DE_SDH *e;
2063 struct NTFS_DE_SDH sdh_e;
2064 struct NTFS_DE_SII sii_e;
2065 struct SECURITY_HDR *d_security;
a81f47c4 2066 u32 new_sec_size = size_sd + sizeof(struct SECURITY_HDR);
fa3cacf5 2067 u32 aligned_sec_size = ALIGN(new_sec_size, 16);
82cae269
KK		 2068 struct SECURITY_KEY hash_key;
2069 struct ntfs_fnd *fnd_sdh = NULL;
2070 const struct INDEX_ROOT *root_sdh;
2071 const struct INDEX_ROOT *root_sii;
2072 u64 mirr_off, new_sds_size;
2073 u32 next, left;
2074
2075 static_assert((1 << Log2OfSecurityDescriptorsBlockSize) ==
2076 SecurityDescriptorsBlockSize);
2077
2078 hash_key.hash = security_hash(sd, size_sd);
2079 hash_key.sec_id = SECURITY_ID_INVALID;
2080
2081 if (inserted)
2082 *inserted = false;
2083 *security_id = SECURITY_ID_INVALID;
2084
e8b8e97f 2085 /* Allocate a temporal buffer. */
195c52bd 2086 d_security = kzalloc(aligned_sec_size, GFP_NOFS);
82cae269
KK		 2087 if (!d_security)
2088 return -ENOMEM;
2089
2090 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_SECURITY);
2091
2092 fnd_sdh = fnd_get();
2093 if (!fnd_sdh) {
2094 err = -ENOMEM;
2095 goto out;
2096 }
2097
2098 root_sdh = indx_get_root(indx_sdh, ni, NULL, NULL);
2099 if (!root_sdh) {
2100 err = -EINVAL;
2101 goto out;
2102 }
2103
2104 root_sii = indx_get_root(indx_sii, ni, NULL, NULL);
2105 if (!root_sii) {
2106 err = -EINVAL;
2107 goto out;
2108 }
2109
2110 /*
e8b8e97f
KA		 2111 * Check if such security already exists.
2112 * Use "SDH" and hash -> to get the offset in "SDS".
82cae269
KK		 2113 */
2114 err = indx_find(indx_sdh, ni, root_sdh, &hash_key, sizeof(hash_key),
2115 &d_security->key.sec_id, &diff, (struct NTFS_DE **)&e,
2116 fnd_sdh);
2117 if (err)
2118 goto out;
2119
2120 while (e) {
2121 if (le32_to_cpu(e->sec_hdr.size) == new_sec_size) {
2122 err = ntfs_read_run_nb(sbi, &ni->file.run,
2123 le64_to_cpu(e->sec_hdr.off),
2124 d_security, new_sec_size, NULL);
2125 if (err)
2126 goto out;
2127
2128 if (le32_to_cpu(d_security->size) == new_sec_size &&
2129 d_security->key.hash == hash_key.hash &&
2130 !memcmp(d_security + 1, sd, size_sd)) {
2131 *security_id = d_security->key.sec_id;
e8b8e97f 2132 /* Such security already exists. */
82cae269
KK		 2133 err = 0;
2134 goto out;
2135 }
2136 }
2137
2138 err = indx_find_sort(indx_sdh, ni, root_sdh,
2139 (struct NTFS_DE **)&e, fnd_sdh);
2140 if (err)
2141 goto out;
2142
2143 if (!e || e->key.hash != hash_key.hash)
2144 break;
2145 }
2146
e8b8e97f 2147 /* Zero unused space. */
82cae269
KK		 2148 next = sbi->security.next_off & (SecurityDescriptorsBlockSize - 1);
2149 left = SecurityDescriptorsBlockSize - next;
2150
e8b8e97f 2151 /* Zero gap until SecurityDescriptorsBlockSize. */
82cae269 2152 if (left < new_sec_size) {
e8b8e97f 2153 /* Zero "left" bytes from sbi->security.next_off. */
82cae269
KK		 2154 sbi->security.next_off += SecurityDescriptorsBlockSize + left;
2155 }
2156
e8b8e97f 2157 /* Zero tail of previous security. */
82cae269
KK		 2158 //used = ni->vfs_inode.i_size & (SecurityDescriptorsBlockSize - 1);
2159
2160 /*
2161 * Example:
2162 * 0x40438 == ni->vfs_inode.i_size
2163 * 0x00440 == sbi->security.next_off
2164 * need to zero [0x438-0x440)
2165 * if (next > used) {
2166 * u32 tozero = next - used;
2167 * zero "tozero" bytes from sbi->security.next_off - tozero
2168 */
2169
e8b8e97f 2170 /* Format new security descriptor. */
82cae269
KK		 2171 d_security->key.hash = hash_key.hash;
2172 d_security->key.sec_id = cpu_to_le32(sbi->security.next_id);
2173 d_security->off = cpu_to_le64(sbi->security.next_off);
2174 d_security->size = cpu_to_le32(new_sec_size);
2175 memcpy(d_security + 1, sd, size_sd);
2176
e8b8e97f 2177 /* Write main SDS bucket. */
82cae269 2178 err = ntfs_sb_write_run(sbi, &ni->file.run, sbi->security.next_off,
63544672 2179 d_security, aligned_sec_size, 0);
82cae269
KK		 2180
2181 if (err)
2182 goto out;
2183
2184 mirr_off = sbi->security.next_off + SecurityDescriptorsBlockSize;
2185 new_sds_size = mirr_off + aligned_sec_size;
2186
2187 if (new_sds_size > ni->vfs_inode.i_size) {
2188 err = attr_set_size(ni, ATTR_DATA, SDS_NAME,
2189 ARRAY_SIZE(SDS_NAME), &ni->file.run,
2190 new_sds_size, &new_sds_size, false, NULL);
2191 if (err)
2192 goto out;
2193 }
2194
e8b8e97f 2195 /* Write copy SDS bucket. */
82cae269 2196 err = ntfs_sb_write_run(sbi, &ni->file.run, mirr_off, d_security,
63544672 2197 aligned_sec_size, 0);
82cae269
KK		 2198 if (err)
2199 goto out;
2200
e8b8e97f 2201 /* Fill SII entry. */
82cae269
KK		 2202 sii_e.de.view.data_off =
2203 cpu_to_le16(offsetof(struct NTFS_DE_SII, sec_hdr));
a81f47c4 2204 sii_e.de.view.data_size = cpu_to_le16(sizeof(struct SECURITY_HDR));
82cae269 2205 sii_e.de.view.res = 0;
a81f47c4 2206 sii_e.de.size = cpu_to_le16(sizeof(struct NTFS_DE_SII));
82cae269
KK		 2207 sii_e.de.key_size = cpu_to_le16(sizeof(d_security->key.sec_id));
2208 sii_e.de.flags = 0;
2209 sii_e.de.res = 0;
2210 sii_e.sec_id = d_security->key.sec_id;
a81f47c4 2211 memcpy(&sii_e.sec_hdr, d_security, sizeof(struct SECURITY_HDR));
82cae269 2212
78ab59fe 2213 err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL, 0);
82cae269
KK		 2214 if (err)
2215 goto out;
2216
e8b8e97f 2217 /* Fill SDH entry. */
82cae269
KK		 2218 sdh_e.de.view.data_off =
2219 cpu_to_le16(offsetof(struct NTFS_DE_SDH, sec_hdr));
a81f47c4 2220 sdh_e.de.view.data_size = cpu_to_le16(sizeof(struct SECURITY_HDR));
82cae269
KK		 2221 sdh_e.de.view.res = 0;
2222 sdh_e.de.size = cpu_to_le16(SIZEOF_SDH_DIRENTRY);
2223 sdh_e.de.key_size = cpu_to_le16(sizeof(sdh_e.key));
2224 sdh_e.de.flags = 0;
2225 sdh_e.de.res = 0;
2226 sdh_e.key.hash = d_security->key.hash;
2227 sdh_e.key.sec_id = d_security->key.sec_id;
a81f47c4 2228 memcpy(&sdh_e.sec_hdr, d_security, sizeof(struct SECURITY_HDR));
82cae269
KK		 2229 sdh_e.magic[0] = cpu_to_le16('I');
2230 sdh_e.magic[1] = cpu_to_le16('I');
2231
2232 fnd_clear(fnd_sdh);
2233 err = indx_insert_entry(indx_sdh, ni, &sdh_e.de, (void *)(size_t)1,
78ab59fe 2234 fnd_sdh, 0);
82cae269
KK		 2235 if (err)
2236 goto out;
2237
2238 *security_id = d_security->key.sec_id;
2239 if (inserted)
2240 *inserted = true;
2241
e8b8e97f 2242 /* Update Id and offset for next descriptor. */
82cae269
KK		 2243 sbi->security.next_id += 1;
2244 sbi->security.next_off += aligned_sec_size;
2245
2246out:
2247 fnd_put(fnd_sdh);
2248 mark_inode_dirty(&ni->vfs_inode);
2249 ni_unlock(ni);
195c52bd 2250 kfree(d_security);
82cae269
KK		 2251
2252 return err;
2253}
2254
2255/*
e8b8e97f 2256 * ntfs_reparse_init - Load and parse $Extend/$Reparse.
82cae269
KK		 2257 */
2258int ntfs_reparse_init(struct ntfs_sb_info *sbi)
2259{
2260 int err;
2261 struct ntfs_inode *ni = sbi->reparse.ni;
2262 struct ntfs_index *indx = &sbi->reparse.index_r;
2263 struct ATTRIB *attr;
2264 struct ATTR_LIST_ENTRY *le;
2265 const struct INDEX_ROOT *root_r;
2266
2267 if (!ni)
2268 return 0;
2269
2270 le = NULL;
2271 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SR_NAME,
2272 ARRAY_SIZE(SR_NAME), NULL, NULL);
2273 if (!attr) {
2274 err = -EINVAL;
2275 goto out;
2276 }
2277
2278 root_r = resident_data(attr);
2279 if (root_r->type != ATTR_ZERO ||
2280 root_r->rule != NTFS_COLLATION_TYPE_UINTS) {
2281 err = -EINVAL;
2282 goto out;
2283 }
2284
2285 err = indx_init(indx, sbi, attr, INDEX_MUTEX_SR);
2286 if (err)
2287 goto out;
2288
2289out:
2290 return err;
2291}
2292
2293/*
e8b8e97f 2294 * ntfs_objid_init - Load and parse $Extend/$ObjId.
82cae269
KK		 2295 */
2296int ntfs_objid_init(struct ntfs_sb_info *sbi)
2297{
2298 int err;
2299 struct ntfs_inode *ni = sbi->objid.ni;
2300 struct ntfs_index *indx = &sbi->objid.index_o;
2301 struct ATTRIB *attr;
2302 struct ATTR_LIST_ENTRY *le;
2303 const struct INDEX_ROOT *root;
2304
2305 if (!ni)
2306 return 0;
2307
2308 le = NULL;
2309 attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SO_NAME,
2310 ARRAY_SIZE(SO_NAME), NULL, NULL);
2311 if (!attr) {
2312 err = -EINVAL;
2313 goto out;
2314 }
2315
2316 root = resident_data(attr);
2317 if (root->type != ATTR_ZERO ||
2318 root->rule != NTFS_COLLATION_TYPE_UINTS) {
2319 err = -EINVAL;
2320 goto out;
2321 }
2322
2323 err = indx_init(indx, sbi, attr, INDEX_MUTEX_SO);
2324 if (err)
2325 goto out;
2326
2327out:
2328 return err;
2329}
2330
2331int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid)
2332{
2333 int err;
2334 struct ntfs_inode *ni = sbi->objid.ni;
2335 struct ntfs_index *indx = &sbi->objid.index_o;
2336
2337 if (!ni)
2338 return -EINVAL;
2339
2340 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_OBJID);
2341
2342 err = indx_delete_entry(indx, ni, guid, sizeof(*guid), NULL);
2343
2344 mark_inode_dirty(&ni->vfs_inode);
2345 ni_unlock(ni);
2346
2347 return err;
2348}
2349
2350int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
2351 const struct MFT_REF *ref)
2352{
2353 int err;
2354 struct ntfs_inode *ni = sbi->reparse.ni;
2355 struct ntfs_index *indx = &sbi->reparse.index_r;
2356 struct NTFS_DE_R re;
2357
2358 if (!ni)
2359 return -EINVAL;
2360
2361 memset(&re, 0, sizeof(re));
2362
2363 re.de.view.data_off = cpu_to_le16(offsetof(struct NTFS_DE_R, zero));
2364 re.de.size = cpu_to_le16(sizeof(struct NTFS_DE_R));
2365 re.de.key_size = cpu_to_le16(sizeof(re.key));
2366
2367 re.key.ReparseTag = rtag;
2368 memcpy(&re.key.ref, ref, sizeof(*ref));
2369
2370 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE);
2371
78ab59fe 2372 err = indx_insert_entry(indx, ni, &re.de, NULL, NULL, 0);
82cae269
KK		 2373
2374 mark_inode_dirty(&ni->vfs_inode);
2375 ni_unlock(ni);
2376
2377 return err;
2378}
2379
2380int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag,
2381 const struct MFT_REF *ref)
2382{
2383 int err, diff;
2384 struct ntfs_inode *ni = sbi->reparse.ni;
2385 struct ntfs_index *indx = &sbi->reparse.index_r;
2386 struct ntfs_fnd *fnd = NULL;
2387 struct REPARSE_KEY rkey;
2388 struct NTFS_DE_R *re;
2389 struct INDEX_ROOT *root_r;
2390
2391 if (!ni)
2392 return -EINVAL;
2393
2394 rkey.ReparseTag = rtag;
2395 rkey.ref = *ref;
2396
2397 mutex_lock_nested(&ni->ni_lock, NTFS_INODE_MUTEX_REPARSE);
2398
2399 if (rtag) {
2400 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL);
2401 goto out1;
2402 }
2403
2404 fnd = fnd_get();
2405 if (!fnd) {
2406 err = -ENOMEM;
2407 goto out1;
2408 }
2409
2410 root_r = indx_get_root(indx, ni, NULL, NULL);
2411 if (!root_r) {
2412 err = -EINVAL;
2413 goto out;
2414 }
2415
e8b8e97f 2416 /* 1 - forces to ignore rkey.ReparseTag when comparing keys. */
82cae269
KK		 2417 err = indx_find(indx, ni, root_r, &rkey, sizeof(rkey), (void *)1, &diff,
2418 (struct NTFS_DE **)&re, fnd);
2419 if (err)
2420 goto out;
2421
2422 if (memcmp(&re->key.ref, ref, sizeof(*ref))) {
e8b8e97f 2423 /* Impossible. Looks like volume corrupt? */
82cae269
KK		 2424 goto out;
2425 }
2426
2427 memcpy(&rkey, &re->key, sizeof(rkey));
2428
2429 fnd_put(fnd);
2430 fnd = NULL;
2431
2432 err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL);
2433 if (err)
2434 goto out;
2435
2436out:
2437 fnd_put(fnd);
2438
2439out1:
2440 mark_inode_dirty(&ni->vfs_inode);
2441 ni_unlock(ni);
2442
2443 return err;
2444}
2445
2446static inline void ntfs_unmap_and_discard(struct ntfs_sb_info *sbi, CLST lcn,
2447 CLST len)
2448{
2449 ntfs_unmap_meta(sbi->sb, lcn, len);
2450 ntfs_discard(sbi, lcn, len);
2451}
2452
2453void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim)
2454{
8335ebe1 2455 CLST end, i, zone_len, zlen;
82cae269 2456 struct wnd_bitmap *wnd = &sbi->used.bitmap;
bfbe5b31 2457 bool dirty = false;
82cae269
KK		 2458
2459 down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS);
2460 if (!wnd_is_used(wnd, lcn, len)) {
bfbe5b31
KK		 2461 /* mark volume as dirty out of wnd->rw_lock */
2462 dirty = true;
82cae269
KK		 2463
2464 end = lcn + len;
2465 len = 0;
2466 for (i = lcn; i < end; i++) {
2467 if (wnd_is_used(wnd, i, 1)) {
2468 if (!len)
2469 lcn = i;
2470 len += 1;
2471 continue;
2472 }
2473
2474 if (!len)
2475 continue;
2476
2477 if (trim)
2478 ntfs_unmap_and_discard(sbi, lcn, len);
2479
2480 wnd_set_free(wnd, lcn, len);
2481 len = 0;
2482 }
2483
2484 if (!len)
2485 goto out;
2486 }
2487
2488 if (trim)
2489 ntfs_unmap_and_discard(sbi, lcn, len);
2490 wnd_set_free(wnd, lcn, len);
2491
8335ebe1
KK		 2492 /* append to MFT zone, if possible. */
2493 zone_len = wnd_zone_len(wnd);
2494 zlen = min(zone_len + len, sbi->zone_max);
2495
2496 if (zlen == zone_len) {
2497 /* MFT zone already has maximum size. */
2498 } else if (!zone_len) {
8039edba
KK		 2499 /* Create MFT zone only if 'zlen' is large enough. */
2500 if (zlen == sbi->zone_max)
2501 wnd_zone_set(wnd, lcn, zlen);
8335ebe1
KK		 2502 } else {
2503 CLST zone_lcn = wnd_zone_bit(wnd);
2504
2505 if (lcn + len == zone_lcn) {
2506 /* Append into head MFT zone. */
2507 wnd_zone_set(wnd, lcn, zlen);
2508 } else if (zone_lcn + zone_len == lcn) {
2509 /* Append into tail MFT zone. */
2510 wnd_zone_set(wnd, zone_lcn, zlen);
2511 }
2512 }
2513
82cae269
KK		 2514out:
2515 up_write(&wnd->rw_lock);
bfbe5b31
KK		 2516 if (dirty)
2517 ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
82cae269
KK		 2518}
2519
2520/*
e8b8e97f 2521 * run_deallocate - Deallocate clusters.
82cae269 2522 */
a81f47c4
KK		 2523int run_deallocate(struct ntfs_sb_info *sbi, const struct runs_tree *run,
2524 bool trim)
82cae269
KK		 2525{
2526 CLST lcn, len;
2527 size_t idx = 0;
2528
2529 while (run_get_entry(run, idx++, NULL, &lcn, &len)) {
2530 if (lcn == SPARSE_LCN)
2531 continue;
2532
2533 mark_as_free_ex(sbi, lcn, len, trim);
2534 }
2535
2536 return 0;
2537}
1d07a9df
DP		 2538
2539static inline bool name_has_forbidden_chars(const struct le_str *fname)
2540{
2541 int i, ch;
2542
2543 /* check for forbidden chars */
2544 for (i = 0; i < fname->len; ++i) {
2545 ch = le16_to_cpu(fname->name[i]);
2546
2547 /* control chars */
2548 if (ch < 0x20)
2549 return true;
2550
2551 switch (ch) {
2552 /* disallowed by Windows */
2553 case '\\':
2554 case '/':
2555 case ':':
2556 case '*':
2557 case '?':
2558 case '<':
2559 case '>':
2560 case '|':
2561 case '\"':
2562 return true;
2563
2564 default:
2565 /* allowed char */
2566 break;
2567 }
2568 }
2569
2570 /* file names cannot end with space or . */
2571 if (fname->len > 0) {
2572 ch = le16_to_cpu(fname->name[fname->len - 1]);
2573 if (ch == ' ' || ch == '.')
2574 return true;
2575 }
2576
2577 return false;
2578}
2579
a81f47c4 2580static inline bool is_reserved_name(const struct ntfs_sb_info *sbi,
1d07a9df
DP		 2581 const struct le_str *fname)
2582{
2583 int port_digit;
2584 const __le16 *name = fname->name;
2585 int len = fname->len;
a81f47c4 2586 const u16 *upcase = sbi->upcase;
1d07a9df
DP		 2587
2588 /* check for 3 chars reserved names (device names) */
2589 /* name by itself or with any extension is forbidden */
2590 if (len == 3 || (len > 3 && le16_to_cpu(name[3]) == '.'))
2591 if (!ntfs_cmp_names(name, 3, CON_NAME, 3, upcase, false) ||
2592 !ntfs_cmp_names(name, 3, NUL_NAME, 3, upcase, false) ||
2593 !ntfs_cmp_names(name, 3, AUX_NAME, 3, upcase, false) ||
2594 !ntfs_cmp_names(name, 3, PRN_NAME, 3, upcase, false))
2595 return true;
2596
2597 /* check for 4 chars reserved names (port name followed by 1..9) */
2598 /* name by itself or with any extension is forbidden */
2599 if (len == 4 || (len > 4 && le16_to_cpu(name[4]) == '.')) {
2600 port_digit = le16_to_cpu(name[3]);
2601 if (port_digit >= '1' && port_digit <= '9')
6827d50b
KK		 2602 if (!ntfs_cmp_names(name, 3, COM_NAME, 3, upcase,
2603 false) ||
2604 !ntfs_cmp_names(name, 3, LPT_NAME, 3, upcase,
2605 false))
1d07a9df
DP		 2606 return true;
2607 }
2608
2609 return false;
2610}
2611
2612/*
2613 * valid_windows_name - Check if a file name is valid in Windows.
2614 */
2615bool valid_windows_name(struct ntfs_sb_info *sbi, const struct le_str *fname)
2616{
2617 return !name_has_forbidden_chars(fname) &&
2618 !is_reserved_name(sbi, fname);
2619}
7832e123
KK		 2620
2621/*
2622 * ntfs_set_label - updates current ntfs label.
2623 */
2624int ntfs_set_label(struct ntfs_sb_info *sbi, u8 *label, int len)
2625{
2626 int err;
2627 struct ATTRIB *attr;
2628 struct ntfs_inode *ni = sbi->volume.ni;
2629 const u8 max_ulen = 0x80; /* TODO: use attrdef to get maximum length */
2630 /* Allocate PATH_MAX bytes. */
2631 struct cpu_str *uni = __getname();
2632
2633 if (!uni)
2634 return -ENOMEM;
2635
2636 err = ntfs_nls_to_utf16(sbi, label, len, uni, (PATH_MAX - 2) / 2,
2637 UTF16_LITTLE_ENDIAN);
2638 if (err < 0)
2639 goto out;
2640
2641 if (uni->len > max_ulen) {
2642 ntfs_warn(sbi->sb, "new label is too long");
2643 err = -EFBIG;
2644 goto out;
2645 }
2646
2647 ni_lock(ni);
2648
2649 /* Ignore any errors. */
2650 ni_remove_attr(ni, ATTR_LABEL, NULL, 0, false, NULL);
2651
2652 err = ni_insert_resident(ni, uni->len * sizeof(u16), ATTR_LABEL, NULL,
2653 0, &attr, NULL, NULL);
2654 if (err < 0)
2655 goto unlock_out;
2656
2657 /* write new label in on-disk struct. */
2658 memcpy(resident_data(attr), uni->name, uni->len * sizeof(u16));
2659
2660 /* update cached value of current label. */
2661 if (len >= ARRAY_SIZE(sbi->volume.label))
2662 len = ARRAY_SIZE(sbi->volume.label) - 1;
2663 memcpy(sbi->volume.label, label, len);
2664 sbi->volume.label[len] = 0;
2665 mark_inode_dirty_sync(&ni->vfs_inode);
2666
2667unlock_out:
2668 ni_unlock(ni);
2669
2670 if (!err)
2671 err = _ni_write_inode(&ni->vfs_inode, 0);
2672
2673out:
2674 __putname(uni);
2675 return err;
2676}
Linux 6.x block layer and io_uring tree(s)