1 // SPDX-License-Identifier: GPL-2.0
4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
14 static inline int compare_attr(const struct ATTRIB *left, enum ATTR_TYPE type,
15 const __le16 *name, u8 name_len,
18 /* First, compare the type codes. */
19 int diff = le32_to_cpu(left->type) - le32_to_cpu(type);
24 /* They have the same type code, so we have to compare the names. */
25 return ntfs_cmp_names(attr_name(left), left->name_len, name, name_len,
32 * Return: Unused attribute id that is less than mrec->next_attr_id.
34 static __le16 mi_new_attt_id(struct mft_inode *mi)
36 u16 free_id, max_id, t16;
37 struct MFT_REC *rec = mi->mrec;
41 id = rec->next_attr_id;
42 free_id = le16_to_cpu(id);
43 if (free_id < 0x7FFF) {
44 rec->next_attr_id = cpu_to_le16(free_id + 1);
48 /* One record can store up to 1024/24 ~= 42 attributes. */
55 attr = mi_enum_attr(mi, attr);
57 rec->next_attr_id = cpu_to_le16(max_id + 1);
59 return cpu_to_le16(free_id);
62 t16 = le16_to_cpu(attr->id);
66 } else if (max_id < t16)
71 int mi_get(struct ntfs_sb_info *sbi, CLST rno, struct mft_inode **mi)
74 struct mft_inode *m = kzalloc(sizeof(struct mft_inode), GFP_NOFS);
79 err = mi_init(m, sbi, rno);
85 err = mi_read(m, false);
95 void mi_put(struct mft_inode *mi)
101 int mi_init(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno)
105 mi->mrec = kmalloc(sbi->record_size, GFP_NOFS);
113 * mi_read - Read MFT data.
115 int mi_read(struct mft_inode *mi, bool is_mft)
118 struct MFT_REC *rec = mi->mrec;
119 struct ntfs_sb_info *sbi = mi->sbi;
120 u32 bpr = sbi->record_size;
121 u64 vbo = (u64)mi->rno << sbi->record_bits;
122 struct ntfs_inode *mft_ni = sbi->mft.ni;
123 struct runs_tree *run = mft_ni ? &mft_ni->file.run : NULL;
124 struct rw_semaphore *rw_lock = NULL;
126 if (is_mounted(sbi)) {
127 if (!is_mft && mft_ni) {
128 rw_lock = &mft_ni->file.run_lock;
133 err = ntfs_read_bh(sbi, run, vbo, &rec->rhdr, bpr, &mi->nb);
139 if (err == -E_NTFS_FIXUP) {
151 err = attr_load_runs_vcn(mft_ni, ATTR_DATA, NULL, 0, run,
152 vbo >> sbi->cluster_bits);
162 err = ntfs_read_bh(sbi, run, vbo, &rec->rhdr, bpr, &mi->nb);
166 if (err == -E_NTFS_FIXUP) {
174 /* Check field 'total' only here. */
175 if (le32_to_cpu(rec->total) != bpr) {
183 if (err == -E_NTFS_CORRUPT) {
184 ntfs_err(sbi->sb, "mft corrupted");
185 ntfs_set_state(sbi, NTFS_DIRTY_ERROR);
192 struct ATTRIB *mi_enum_attr(struct mft_inode *mi, struct ATTRIB *attr)
194 const struct MFT_REC *rec = mi->mrec;
195 u32 used = le32_to_cpu(rec->used);
200 u32 total = le32_to_cpu(rec->total);
202 off = le16_to_cpu(rec->attr_off);
207 if (off >= used || off < MFTRECORD_FIXUP_OFFSET_1 ||
208 !IS_ALIGNED(off, 4)) {
212 /* Skip non-resident records. */
213 if (!is_rec_inuse(rec))
216 attr = Add2Ptr(rec, off);
218 /* Check if input attr inside record. */
219 off = PtrOffset(rec, attr);
223 asize = le32_to_cpu(attr->size);
224 if (asize < SIZEOF_RESIDENT) {
225 /* Impossible 'cause we should not return such attribute. */
229 attr = Add2Ptr(attr, asize);
233 asize = le32_to_cpu(attr->size);
235 /* Can we use the first field (attr->type). */
236 if (off + 8 > used) {
237 static_assert(ALIGN(sizeof(enum ATTR_TYPE), 8) == 8);
241 if (attr->type == ATTR_END) {
242 /* End of enumeration. */
246 /* 0x100 is last known attribute for now. */
247 t32 = le32_to_cpu(attr->type);
248 if ((t32 & 0xf) || (t32 > 0x100))
251 /* Check overflow and boundary. */
252 if (off + asize < off || off + asize > used)
255 /* Check size of attribute. */
256 if (!attr->non_res) {
257 if (asize < SIZEOF_RESIDENT)
260 t16 = le16_to_cpu(attr->res.data_off);
265 t32 = le32_to_cpu(attr->res.data_size);
266 if (t16 + t32 > asize)
269 if (attr->name_len &&
270 le16_to_cpu(attr->name_off) + sizeof(short) * attr->name_len > t16) {
277 /* Check some nonresident fields. */
278 if (attr->name_len &&
279 le16_to_cpu(attr->name_off) + sizeof(short) * attr->name_len >
280 le16_to_cpu(attr->nres.run_off)) {
284 if (attr->nres.svcn || !is_attr_ext(attr)) {
285 if (asize + 8 < SIZEOF_NONRESIDENT)
288 if (attr->nres.c_unit)
290 } else if (asize + 8 < SIZEOF_NONRESIDENT_EX)
297 * mi_find_attr - Find the attribute by type and name and id.
299 struct ATTRIB *mi_find_attr(struct mft_inode *mi, struct ATTRIB *attr,
300 enum ATTR_TYPE type, const __le16 *name,
301 size_t name_len, const __le16 *id)
303 u32 type_in = le32_to_cpu(type);
307 attr = mi_enum_attr(mi, attr);
311 atype = le32_to_cpu(attr->type);
318 if (attr->name_len != name_len)
321 if (name_len && memcmp(attr_name(attr), name, name_len * sizeof(short)))
324 if (id && *id != attr->id)
330 int mi_write(struct mft_inode *mi, int wait)
334 struct ntfs_sb_info *sbi;
342 err = ntfs_write_bh(sbi, &rec->rhdr, &mi->nb, wait);
346 if (mi->rno < sbi->mft.recs_mirr)
347 sbi->flags |= NTFS_FLAGS_MFTMIRR;
354 int mi_format_new(struct mft_inode *mi, struct ntfs_sb_info *sbi, CLST rno,
355 __le16 flags, bool is_mft)
360 u64 vbo = (u64)rno << sbi->record_bits;
362 err = mi_init(mi, sbi, rno);
368 if (rno == MFT_REC_MFT) {
370 } else if (rno < MFT_REC_FREE) {
372 } else if (rno >= sbi->mft.used) {
374 } else if (mi_read(mi, is_mft)) {
376 } else if (rec->rhdr.sign == NTFS_FILE_SIGNATURE) {
377 /* Record is reused. Update its sequence number. */
378 seq = le16_to_cpu(rec->seq) + 1;
383 memcpy(rec, sbi->new_rec, sbi->record_size);
385 rec->seq = cpu_to_le16(seq);
386 rec->flags = RECORD_FLAG_IN_USE | flags;
391 struct ntfs_inode *ni = sbi->mft.ni;
394 if (is_mounted(sbi) && !is_mft) {
395 down_read(&ni->file.run_lock);
399 err = ntfs_get_bh(sbi, &ni->file.run, vbo, sbi->record_size,
402 up_read(&ni->file.run_lock);
409 * mi_mark_free - Mark record as unused and marks it as free in bitmap.
411 void mi_mark_free(struct mft_inode *mi)
414 struct ntfs_sb_info *sbi = mi->sbi;
416 if (rno >= MFT_REC_RESERVED && rno < MFT_REC_FREE) {
417 ntfs_clear_mft_tail(sbi, rno, rno + 1);
423 clear_rec_inuse(mi->mrec);
427 ntfs_mark_rec_free(sbi, rno);
431 * mi_insert_attr - Reserve space for new attribute.
433 * Return: Not full constructed attribute or NULL if not possible to create.
435 struct ATTRIB *mi_insert_attr(struct mft_inode *mi, enum ATTR_TYPE type,
436 const __le16 *name, u8 name_len, u32 asize,
442 struct MFT_REC *rec = mi->mrec;
443 struct ntfs_sb_info *sbi = mi->sbi;
444 u32 used = le32_to_cpu(rec->used);
445 const u16 *upcase = sbi->upcase;
448 /* Can we insert mi attribute? */
449 if (used + asize > mi->sbi->record_size)
453 * Scan through the list of attributes to find the point
454 * at which we should insert it.
457 while ((attr = mi_enum_attr(mi, attr))) {
458 diff = compare_attr(attr, type, name, name_len, upcase);
464 if (!is_attr_indexed(attr))
470 tail = 8; /* Not used, just to suppress warning. */
471 attr = Add2Ptr(rec, used - 8);
473 tail = used - PtrOffset(rec, attr);
476 id = mi_new_attt_id(mi);
478 memmove(Add2Ptr(attr, asize), attr, tail);
479 memset(attr, 0, asize);
482 attr->size = cpu_to_le32(asize);
483 attr->name_len = name_len;
484 attr->name_off = cpu_to_le16(name_off);
487 memmove(Add2Ptr(attr, name_off), name, name_len * sizeof(short));
488 rec->used = cpu_to_le32(used + asize);
496 * mi_remove_attr - Remove the attribute from record.
498 * NOTE: The source attr will point to next attribute.
500 bool mi_remove_attr(struct ntfs_inode *ni, struct mft_inode *mi,
503 struct MFT_REC *rec = mi->mrec;
504 u32 aoff = PtrOffset(rec, attr);
505 u32 used = le32_to_cpu(rec->used);
506 u32 asize = le32_to_cpu(attr->size);
508 if (aoff + asize > used)
511 if (ni && is_attr_indexed(attr)) {
512 le16_add_cpu(&ni->mi.mrec->hard_links, -1);
517 memmove(attr, Add2Ptr(attr, asize), used - aoff);
518 rec->used = cpu_to_le32(used);
524 /* bytes = "new attribute size" - "old attribute size" */
525 bool mi_resize_attr(struct mft_inode *mi, struct ATTRIB *attr, int bytes)
527 struct MFT_REC *rec = mi->mrec;
528 u32 aoff = PtrOffset(rec, attr);
529 u32 total, used = le32_to_cpu(rec->used);
530 u32 nsize, asize = le32_to_cpu(attr->size);
531 u32 rsize = le32_to_cpu(attr->res.data_size);
532 int tail = (int)(used - aoff - asize);
536 if (tail < 0 || aoff >= used)
542 total = le32_to_cpu(rec->total);
543 next = Add2Ptr(attr, asize);
546 dsize = ALIGN(bytes, 8);
547 if (used + dsize > total)
549 nsize = asize + dsize;
551 memmove(next + dsize, next, tail);
552 memset(next, 0, dsize);
556 dsize = ALIGN(-bytes, 8);
559 nsize = asize - dsize;
560 memmove(next - dsize, next, tail);
565 rec->used = cpu_to_le32(used);
566 attr->size = cpu_to_le32(nsize);
568 attr->res.data_size = cpu_to_le32(rsize);
574 int mi_pack_runs(struct mft_inode *mi, struct ATTRIB *attr,
575 struct runs_tree *run, CLST len)
578 struct ntfs_sb_info *sbi = mi->sbi;
581 struct MFT_REC *rec = mi->mrec;
582 CLST svcn = le64_to_cpu(attr->nres.svcn);
583 u32 used = le32_to_cpu(rec->used);
584 u32 aoff = PtrOffset(rec, attr);
585 u32 asize = le32_to_cpu(attr->size);
586 char *next = Add2Ptr(attr, asize);
587 u16 run_off = le16_to_cpu(attr->nres.run_off);
588 u32 run_size = asize - run_off;
589 u32 tail = used - aoff - asize;
590 u32 dsize = sbi->record_size - used;
592 /* Make a maximum gap in current record. */
593 memmove(next + dsize, next, tail);
595 /* Pack as much as possible. */
596 err = run_pack(run, svcn, len, Add2Ptr(attr, run_off), run_size + dsize,
599 memmove(next, next + dsize, tail);
603 new_run_size = ALIGN(err, 8);
605 memmove(next + new_run_size - run_size, next + dsize, tail);
607 attr->size = cpu_to_le32(asize + new_run_size - run_size);
608 attr->nres.evcn = cpu_to_le64(svcn + plen - 1);
609 rec->used = cpu_to_le32(used + new_run_size - run_size);