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> 11 #include <linux/nls.h> 12 13 #include "debug.h" 14 #include "ntfs.h" 15 #include "ntfs_fs.h" 16 17 static inline int compare_attr(const struct ATTRIB *left, enum ATTR_TYPE type, 18 const __le16 *name, u8 name_len, 19 const u16 *upcase) 20 { 21 /* First, compare the type codes. */ 22 int diff = le32_to_cpu(left->type) - le32_to_cpu(type); 23 24 if (diff) 25 return diff; 26 27 /* They have the same type code, so we have to compare the names. */ 28 return ntfs_cmp_names(attr_name(left), left->name_len, name, name_len, 29 upcase, true); 30 } 31 32 /* 33 * mi_new_attt_id 34 * 35 * Return: Unused attribute id that is less than mrec->next_attr_id. 36 */ 37 static __le16 mi_new_attt_id(struct mft_inode *mi) 38 { 39 u16 free_id, max_id, t16; 40 struct MFT_REC *rec = mi->mrec; 41 struct ATTRIB *attr; 42 __le16 id; 43 44 id = rec->next_attr_id; 45 free_id = le16_to_cpu(id); 46 if (free_id < 0x7FFF) { 47 rec->next_attr_id = cpu_to_le16(free_id + 1); 48 return id; 49 } 50 51 /* One record can store up to 1024/24 ~= 42 attributes. */ 52 free_id = 0; 53 max_id = 0; 54 55 attr = NULL; 56 57 for (;;) { 58 attr = mi_enum_attr(mi, attr); 59 if (!attr) { 60 rec->next_attr_id = cpu_to_le16(max_id + 1); 61 mi->dirty = true; 62 return cpu_to_le16(free_id); 63 } 64 65 t16 = le16_to_cpu(attr->id); 66 if (t16 == free_id) { 67 free_id += 1; 68 attr = NULL; 69 } else if (max_id < t16) 70 max_id = t16; 71 } 72 } 73 74 int mi_get(struct ntfs_sb_info *sbi, CLST rno, struct mft_inode **mi) 75 { 76 int err; 77 struct mft_inode *m = kzalloc(sizeof(struct mft_inode), GFP_NOFS); 78 79 if (!m) 80 return -ENOMEM; 81 82 err = mi_init(m, sbi, rno); 83 if (err) { 84 kfree(m); 85 return err; 86 } 87 88 err = mi_read(m, false); 89 if (err) { 90 mi_put(m); 91 return err; 92 } 93 94 *mi = m; 95 return 0; 96 } 97 98 void mi_put(struct mft_inode *mi) 99 { 100 mi_clear(mi); 101 kfree(mi); 102 } 103 104 int mi_init(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno) 105 { 106 mi->sbi = sbi; 107 mi->rno = rno; 108 mi->mrec = kmalloc(sbi->record_size, GFP_NOFS); 109 if (!mi->mrec) 110 return -ENOMEM; 111 112 return 0; 113 } 114 115 /* 116 * mi_read - Read MFT data. 117 */ 118 int mi_read(struct mft_inode *mi, bool is_mft) 119 { 120 int err; 121 struct MFT_REC *rec = mi->mrec; 122 struct ntfs_sb_info *sbi = mi->sbi; 123 u32 bpr = sbi->record_size; 124 u64 vbo = (u64)mi->rno << sbi->record_bits; 125 struct ntfs_inode *mft_ni = sbi->mft.ni; 126 struct runs_tree *run = mft_ni ? &mft_ni->file.run : NULL; 127 struct rw_semaphore *rw_lock = NULL; 128 129 if (is_mounted(sbi)) { 130 if (!is_mft) { 131 rw_lock = &mft_ni->file.run_lock; 132 down_read(rw_lock); 133 } 134 } 135 136 err = ntfs_read_bh(sbi, run, vbo, &rec->rhdr, bpr, &mi->nb); 137 if (rw_lock) 138 up_read(rw_lock); 139 if (!err) 140 goto ok; 141 142 if (err == -E_NTFS_FIXUP) { 143 mi->dirty = true; 144 goto ok; 145 } 146 147 if (err != -ENOENT) 148 goto out; 149 150 if (rw_lock) { 151 ni_lock(mft_ni); 152 down_write(rw_lock); 153 } 154 err = attr_load_runs_vcn(mft_ni, ATTR_DATA, NULL, 0, &mft_ni->file.run, 155 vbo >> sbi->cluster_bits); 156 if (rw_lock) { 157 up_write(rw_lock); 158 ni_unlock(mft_ni); 159 } 160 if (err) 161 goto out; 162 163 if (rw_lock) 164 down_read(rw_lock); 165 err = ntfs_read_bh(sbi, run, vbo, &rec->rhdr, bpr, &mi->nb); 166 if (rw_lock) 167 up_read(rw_lock); 168 169 if (err == -E_NTFS_FIXUP) { 170 mi->dirty = true; 171 goto ok; 172 } 173 if (err) 174 goto out; 175 176 ok: 177 /* Check field 'total' only here. */ 178 if (le32_to_cpu(rec->total) != bpr) { 179 err = -EINVAL; 180 goto out; 181 } 182 183 return 0; 184 185 out: 186 return err; 187 } 188 189 struct ATTRIB *mi_enum_attr(struct mft_inode *mi, struct ATTRIB *attr) 190 { 191 const struct MFT_REC *rec = mi->mrec; 192 u32 used = le32_to_cpu(rec->used); 193 u32 t32, off, asize; 194 u16 t16; 195 196 if (!attr) { 197 u32 total = le32_to_cpu(rec->total); 198 199 off = le16_to_cpu(rec->attr_off); 200 201 if (used > total) 202 return NULL; 203 204 if (off >= used || off < MFTRECORD_FIXUP_OFFSET_1 || 205 !IS_ALIGNED(off, 4)) { 206 return NULL; 207 } 208 209 /* Skip non-resident records. */ 210 if (!is_rec_inuse(rec)) 211 return NULL; 212 213 attr = Add2Ptr(rec, off); 214 } else { 215 /* Check if input attr inside record. */ 216 off = PtrOffset(rec, attr); 217 if (off >= used) 218 return NULL; 219 220 asize = le32_to_cpu(attr->size); 221 if (asize < SIZEOF_RESIDENT) { 222 /* Impossible 'cause we should not return such attribute. */ 223 return NULL; 224 } 225 226 attr = Add2Ptr(attr, asize); 227 off += asize; 228 } 229 230 asize = le32_to_cpu(attr->size); 231 232 /* Can we use the first field (attr->type). */ 233 if (off + 8 > used) { 234 static_assert(ALIGN(sizeof(enum ATTR_TYPE), 8) == 8); 235 return NULL; 236 } 237 238 if (attr->type == ATTR_END) { 239 /* End of enumeration. */ 240 return NULL; 241 } 242 243 /* 0x100 is last known attribute for now. */ 244 t32 = le32_to_cpu(attr->type); 245 if ((t32 & 0xf) || (t32 > 0x100)) 246 return NULL; 247 248 /* Check boundary. */ 249 if (off + asize > used) 250 return NULL; 251 252 /* Check size of attribute. */ 253 if (!attr->non_res) { 254 if (asize < SIZEOF_RESIDENT) 255 return NULL; 256 257 t16 = le16_to_cpu(attr->res.data_off); 258 259 if (t16 > asize) 260 return NULL; 261 262 t32 = le32_to_cpu(attr->res.data_size); 263 if (t16 + t32 > asize) 264 return NULL; 265 266 return attr; 267 } 268 269 /* Check some nonresident fields. */ 270 if (attr->name_len && 271 le16_to_cpu(attr->name_off) + sizeof(short) * attr->name_len > 272 le16_to_cpu(attr->nres.run_off)) { 273 return NULL; 274 } 275 276 if (attr->nres.svcn || !is_attr_ext(attr)) { 277 if (asize + 8 < SIZEOF_NONRESIDENT) 278 return NULL; 279 280 if (attr->nres.c_unit) 281 return NULL; 282 } else if (asize + 8 < SIZEOF_NONRESIDENT_EX) 283 return NULL; 284 285 return attr; 286 } 287 288 /* 289 * mi_find_attr - Find the attribute by type and name and id. 290 */ 291 struct ATTRIB *mi_find_attr(struct mft_inode *mi, struct ATTRIB *attr, 292 enum ATTR_TYPE type, const __le16 *name, 293 size_t name_len, const __le16 *id) 294 { 295 u32 type_in = le32_to_cpu(type); 296 u32 atype; 297 298 next_attr: 299 attr = mi_enum_attr(mi, attr); 300 if (!attr) 301 return NULL; 302 303 atype = le32_to_cpu(attr->type); 304 if (atype > type_in) 305 return NULL; 306 307 if (atype < type_in) 308 goto next_attr; 309 310 if (attr->name_len != name_len) 311 goto next_attr; 312 313 if (name_len && memcmp(attr_name(attr), name, name_len * sizeof(short))) 314 goto next_attr; 315 316 if (id && *id != attr->id) 317 goto next_attr; 318 319 return attr; 320 } 321 322 int mi_write(struct mft_inode *mi, int wait) 323 { 324 struct MFT_REC *rec; 325 int err; 326 struct ntfs_sb_info *sbi; 327 328 if (!mi->dirty) 329 return 0; 330 331 sbi = mi->sbi; 332 rec = mi->mrec; 333 334 err = ntfs_write_bh(sbi, &rec->rhdr, &mi->nb, wait); 335 if (err) 336 return err; 337 338 if (mi->rno < sbi->mft.recs_mirr) 339 sbi->flags |= NTFS_FLAGS_MFTMIRR; 340 341 mi->dirty = false; 342 343 return 0; 344 } 345 346 int mi_format_new(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno, 347 __le16 flags, bool is_mft) 348 { 349 int err; 350 u16 seq = 1; 351 struct MFT_REC *rec; 352 u64 vbo = (u64)rno << sbi->record_bits; 353 354 err = mi_init(mi, sbi, rno); 355 if (err) 356 return err; 357 358 rec = mi->mrec; 359 360 if (rno == MFT_REC_MFT) { 361 ; 362 } else if (rno < MFT_REC_FREE) { 363 seq = rno; 364 } else if (rno >= sbi->mft.used) { 365 ; 366 } else if (mi_read(mi, is_mft)) { 367 ; 368 } else if (rec->rhdr.sign == NTFS_FILE_SIGNATURE) { 369 /* Record is reused. Update its sequence number. */ 370 seq = le16_to_cpu(rec->seq) + 1; 371 if (!seq) 372 seq = 1; 373 } 374 375 memcpy(rec, sbi->new_rec, sbi->record_size); 376 377 rec->seq = cpu_to_le16(seq); 378 rec->flags = RECORD_FLAG_IN_USE | flags; 379 380 mi->dirty = true; 381 382 if (!mi->nb.nbufs) { 383 struct ntfs_inode *ni = sbi->mft.ni; 384 bool lock = false; 385 386 if (is_mounted(sbi) && !is_mft) { 387 down_read(&ni->file.run_lock); 388 lock = true; 389 } 390 391 err = ntfs_get_bh(sbi, &ni->file.run, vbo, sbi->record_size, 392 &mi->nb); 393 if (lock) 394 up_read(&ni->file.run_lock); 395 } 396 397 return err; 398 } 399 400 /* 401 * mi_mark_free - Mark record as unused and marks it as free in bitmap. 402 */ 403 void mi_mark_free(struct mft_inode *mi) 404 { 405 CLST rno = mi->rno; 406 struct ntfs_sb_info *sbi = mi->sbi; 407 408 if (rno >= MFT_REC_RESERVED && rno < MFT_REC_FREE) { 409 ntfs_clear_mft_tail(sbi, rno, rno + 1); 410 mi->dirty = false; 411 return; 412 } 413 414 if (mi->mrec) { 415 clear_rec_inuse(mi->mrec); 416 mi->dirty = true; 417 mi_write(mi, 0); 418 } 419 ntfs_mark_rec_free(sbi, rno); 420 } 421 422 /* 423 * mi_insert_attr - Reserve space for new attribute. 424 * 425 * Return: Not full constructed attribute or NULL if not possible to create. 426 */ 427 struct ATTRIB *mi_insert_attr(struct mft_inode *mi, enum ATTR_TYPE type, 428 const __le16 *name, u8 name_len, u32 asize, 429 u16 name_off) 430 { 431 size_t tail; 432 struct ATTRIB *attr; 433 __le16 id; 434 struct MFT_REC *rec = mi->mrec; 435 struct ntfs_sb_info *sbi = mi->sbi; 436 u32 used = le32_to_cpu(rec->used); 437 const u16 *upcase = sbi->upcase; 438 int diff; 439 440 /* Can we insert mi attribute? */ 441 if (used + asize > mi->sbi->record_size) 442 return NULL; 443 444 /* 445 * Scan through the list of attributes to find the point 446 * at which we should insert it. 447 */ 448 attr = NULL; 449 while ((attr = mi_enum_attr(mi, attr))) { 450 diff = compare_attr(attr, type, name, name_len, upcase); 451 if (diff > 0) 452 break; 453 if (diff < 0) 454 continue; 455 456 if (!is_attr_indexed(attr)) 457 return NULL; 458 break; 459 } 460 461 if (!attr) { 462 tail = 8; /* Not used, just to suppress warning. */ 463 attr = Add2Ptr(rec, used - 8); 464 } else { 465 tail = used - PtrOffset(rec, attr); 466 } 467 468 id = mi_new_attt_id(mi); 469 470 memmove(Add2Ptr(attr, asize), attr, tail); 471 memset(attr, 0, asize); 472 473 attr->type = type; 474 attr->size = cpu_to_le32(asize); 475 attr->name_len = name_len; 476 attr->name_off = cpu_to_le16(name_off); 477 attr->id = id; 478 479 memmove(Add2Ptr(attr, name_off), name, name_len * sizeof(short)); 480 rec->used = cpu_to_le32(used + asize); 481 482 mi->dirty = true; 483 484 return attr; 485 } 486 487 /* 488 * mi_remove_attr - Remove the attribute from record. 489 * 490 * NOTE: The source attr will point to next attribute. 491 */ 492 bool mi_remove_attr(struct ntfs_inode *ni, struct mft_inode *mi, 493 struct ATTRIB *attr) 494 { 495 struct MFT_REC *rec = mi->mrec; 496 u32 aoff = PtrOffset(rec, attr); 497 u32 used = le32_to_cpu(rec->used); 498 u32 asize = le32_to_cpu(attr->size); 499 500 if (aoff + asize > used) 501 return false; 502 503 if (ni && is_attr_indexed(attr)) { 504 le16_add_cpu(&ni->mi.mrec->hard_links, -1); 505 ni->mi.dirty = true; 506 } 507 508 used -= asize; 509 memmove(attr, Add2Ptr(attr, asize), used - aoff); 510 rec->used = cpu_to_le32(used); 511 mi->dirty = true; 512 513 return true; 514 } 515 516 /* bytes = "new attribute size" - "old attribute size" */ 517 bool mi_resize_attr(struct mft_inode *mi, struct ATTRIB *attr, int bytes) 518 { 519 struct MFT_REC *rec = mi->mrec; 520 u32 aoff = PtrOffset(rec, attr); 521 u32 total, used = le32_to_cpu(rec->used); 522 u32 nsize, asize = le32_to_cpu(attr->size); 523 u32 rsize = le32_to_cpu(attr->res.data_size); 524 int tail = (int)(used - aoff - asize); 525 int dsize; 526 char *next; 527 528 if (tail < 0 || aoff >= used) 529 return false; 530 531 if (!bytes) 532 return true; 533 534 total = le32_to_cpu(rec->total); 535 next = Add2Ptr(attr, asize); 536 537 if (bytes > 0) { 538 dsize = ALIGN(bytes, 8); 539 if (used + dsize > total) 540 return false; 541 nsize = asize + dsize; 542 /* Move tail */ 543 memmove(next + dsize, next, tail); 544 memset(next, 0, dsize); 545 used += dsize; 546 rsize += dsize; 547 } else { 548 dsize = ALIGN(-bytes, 8); 549 if (dsize > asize) 550 return false; 551 nsize = asize - dsize; 552 memmove(next - dsize, next, tail); 553 used -= dsize; 554 rsize -= dsize; 555 } 556 557 rec->used = cpu_to_le32(used); 558 attr->size = cpu_to_le32(nsize); 559 if (!attr->non_res) 560 attr->res.data_size = cpu_to_le32(rsize); 561 mi->dirty = true; 562 563 return true; 564 } 565 566 int mi_pack_runs(struct mft_inode *mi, struct ATTRIB *attr, 567 struct runs_tree *run, CLST len) 568 { 569 int err = 0; 570 struct ntfs_sb_info *sbi = mi->sbi; 571 u32 new_run_size; 572 CLST plen; 573 struct MFT_REC *rec = mi->mrec; 574 CLST svcn = le64_to_cpu(attr->nres.svcn); 575 u32 used = le32_to_cpu(rec->used); 576 u32 aoff = PtrOffset(rec, attr); 577 u32 asize = le32_to_cpu(attr->size); 578 char *next = Add2Ptr(attr, asize); 579 u16 run_off = le16_to_cpu(attr->nres.run_off); 580 u32 run_size = asize - run_off; 581 u32 tail = used - aoff - asize; 582 u32 dsize = sbi->record_size - used; 583 584 /* Make a maximum gap in current record. */ 585 memmove(next + dsize, next, tail); 586 587 /* Pack as much as possible. */ 588 err = run_pack(run, svcn, len, Add2Ptr(attr, run_off), run_size + dsize, 589 &plen); 590 if (err < 0) { 591 memmove(next, next + dsize, tail); 592 return err; 593 } 594 595 new_run_size = ALIGN(err, 8); 596 597 memmove(next + new_run_size - run_size, next + dsize, tail); 598 599 attr->size = cpu_to_le32(asize + new_run_size - run_size); 600 attr->nres.evcn = cpu_to_le64(svcn + plen - 1); 601 rec->used = cpu_to_le32(used + new_run_size - run_size); 602 mi->dirty = true; 603 604 return 0; 605 } 606