From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.9 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, NICE_REPLY_A,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BC299C43463 for ; Fri, 18 Sep 2020 18:32:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3B929206D9 for ; Fri, 18 Sep 2020 18:32:50 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="bzXhAPsz" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726508AbgIRSct (ORCPT ); Fri, 18 Sep 2020 14:32:49 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37002 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726156AbgIRScs (ORCPT ); Fri, 18 Sep 2020 14:32:48 -0400 Received: from mail-wm1-x343.google.com (mail-wm1-x343.google.com [IPv6:2a00:1450:4864:20::343]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B4CE3C0613CE; Fri, 18 Sep 2020 11:32:47 -0700 (PDT) Received: by mail-wm1-x343.google.com with SMTP id e17so6207553wme.0; Fri, 18 Sep 2020 11:32:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:subject:to:cc:references:from:autocrypt:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=VkDJFdAxd0aelGNa3gWzSCahShItwGf5SyK423SY7LU=; b=bzXhAPszHgnjtFoWa6qM/uVxTCUnyW01y3Wr3oBnw0ixfTv4NZrksFfpCr0EjL+QkH ybN1Ejqiarw/ea6c5X8EAV1+dIURKfjOMXQYkRUN9ai39ayDdwOx7BXF/Co/v/020607 du16DckyBKEao5PugS72XbdZrvqSzCwobtUr5uQ7M2yhQNKVx2dbafWNGVerdWBihRY+ 78lKamf63WFsN6LklJZ914JDGMVeP68Pn8m/Tl52yFvoNtQED+Unu3N1PPsT0+IAkwfm 3mnGKmcU5Jivi28zXO94m403xg0r+k0kCctNIK7nl0ajbhvSguHmgv4vuufB1TkB97cC mLrg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:subject:to:cc:references:from:autocrypt :message-id:date:user-agent:mime-version:in-reply-to :content-transfer-encoding:content-language; bh=VkDJFdAxd0aelGNa3gWzSCahShItwGf5SyK423SY7LU=; b=kuvDBt2NMwSMzrLYe7myIuPd7jivAwu9XYCPer305Pa7F6bt/W82AuAs89KKUkew6k qEydu8ivcE/gto0/6RPSQft1vFNpnNu0yvnPSWhC/JKE5Ke5pVeydfwhqcSzovoZPOoE +HwFQb/k3siTpgJHEAuHcUqfMnUvH5INjTWhdFFo9mFyQtszZLk87x8xkP6O3LE4Ai5Y nAsK1zd+50qFjFLPD3LEKtJi0hqXIUS3srFZ3pqwULl5PAfKDiFO7xxaZvtceCubmqik Ar2yljPbDGQI3Fpev7YNgAeSy09x5xj53byddswQqqewWXINh2i7g7z4DTCEkodEbPdk O4Kw== X-Gm-Message-State: AOAM530ithFy45FHnaGL0N6IQMMlElwjZ8aVUkrUp8u0xdTNn9eqkmsi pHwm3e/00htCqoIO8DrzCgw= X-Google-Smtp-Source: ABdhPJwStbAGHUGOTX/xxoXB17YIcn9Q0xxPPgfD1SfGjNWvLvN/ik47PhMBIE/M9jS4Gf61SbCSEw== X-Received: by 2002:a1c:ed09:: with SMTP id l9mr17054361wmh.89.1600453965167; Fri, 18 Sep 2020 11:32:45 -0700 (PDT) Received: from ?IPv6:2a02:8010:64ea:0:fad1:11ff:fead:57db? ([2a02:8010:64ea:0:fad1:11ff:fead:57db]) by smtp.googlemail.com with ESMTPSA id i3sm6500540wrs.4.2020.09.18.11.32.42 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 18 Sep 2020 11:32:44 -0700 (PDT) Subject: Re: [PATCH v6 02/10] fs/ntfs3: Add initialization of super block To: Konstantin Komarov , linux-fsdevel@vger.kernel.org Cc: viro@zeniv.linux.org.uk, linux-kernel@vger.kernel.org, pali@kernel.org, dsterba@suse.cz, aaptel@suse.com, willy@infradead.org, rdunlap@infradead.org, joe@perches.com, nborisov@suse.com References: <20200918162204.3706029-1-almaz.alexandrovich@paragon-software.com> <20200918162204.3706029-3-almaz.alexandrovich@paragon-software.com> From: Mark Harmstone Autocrypt: addr=mark@harmstone.com; keydata= mQENBFp/GMsBCACtFsuHZqHWpHtHuFkNZhMpiZMChyou4X8Ueur3XyF8KM2j6TKkZ5M/72qT EycEM0iU1TYVN/Rb39gBGtRclLFVY1bx4i+aUCzh/4naRxqHgzM2SeeLWHD0qva0gIwjvoRs FP333bWrFKPh5xUmmSXBtBCVqrW+LYX4404tDKUf5wUQ9bQd2ItFRM2mU/l6TUHVY2iMql6I s94Bz5/Zh4BVvs64CbgdyYyQuI4r2tk/Z9Z8M4IjEzQsjSOfArEmb4nj27R3GOauZTO2aKlM 8821rvBjcsMk6iE/NV4SPsfCZ1jvL2UC3CnWYshsGGnfd8m2v0aLFSHZlNd+vedQOTgnABEB AAG0I01hcmsgSGFybXN0b25lIDxtYXJrQGhhcm1zdG9uZS5jb20+iQFOBBMBCAA4FiEEG2Jg KYgV0WRwIJAqbKyhHeAWK+0FAlp/GMsCGy8FCwkIBwIGFQgJCgsCBBYCAwECHgECF4AACgkQ bKyhHeAWK+3vPwf8DcCgo/1CJYyUeldSg8M4hM5Yg5J56T7hV5lWNKSdPYe6NrholYqfaSip UVJDmi8VKkWGqxp+mUT6V4Fz1pEXaWVuFFfYbImlWt9qkPGVrn4b3XWZZPBDe2Z2cU0R4/p0 se60TN8XW7m7HVulD5VFDqrq0bDGqoFpr5RHmaMcoD3NZMqRLG6wHkESrk3P6mvc0qBeDzDU 3Z/blOnqSFSMLg/+wkY4rScvfGP8AdUQ91IV7vIgwlExiTAIjH3Eg78rP2GRM+vaaKNREpTS LM+8ivNgo5S8sQcrNYlg5rA2hJJsT45MO0TuGoN4u4eJf7nC0QaRTEJTsLGnPr7MlxzjirkB DQRafxjLAQgAvkcSlqYuzsqLwPzuzoMzIiAwfvEW3AnZxmZn9bQ+ashB9WnkAy2FZCiI/BPw iiUjqgloaVS2dIrVFAYbynqSbjqhki+uwMliz7/jEporTDmxx7VGzdbcKSCe6rkE/72o6t7K G0r55cmWnkdOWQ965aRnRAFY7Zzd+WLqlzeoseYsNj36RMaqNR7aL7x+kDWnwbw+jgiXtgNB cnKtqmJc04z/sQTa+sUX53syht1Iv4wkATN1W+ZvQySxHNXK1r4NkcDA9ZyFA3NeeIE6ejiO 7RyC0llKXk78t0VQPdGS6HspVhYGJJt21c5vwSzIeZaneKULaxXGwzgYFTroHD9n+QARAQAB iQJsBBgBCAAgFiEEG2JgKYgV0WRwIJAqbKyhHeAWK+0FAlp/GMsCGy4BQAkQbKyhHeAWK+3A dCAEGQEIAB0WIQR6bEAu0hwk2Q9ibSlt5UHXRQtUiwUCWn8YywAKCRBt5UHXRQtUiwdEB/9O pyjmrshY40kwpmPwUfode2Azufd3QRdthnNPAY8Tv9erwsMS3sMh+M9EP+iYJh+AIRO7fDN/ u0AWIqZhHFzCndqZp8JRYULnspXSKPmVSVRIagylKew406XcAVFpEjloUtDhziBN7ykksrAM oLASaBHZpAfp8UAGDrr8Fx1on46rDxsWbh1K1h4LEmkkVooDELjsbN9jvxr8ym8Bkt54Fcpy pTOd8jkt/lJRvnKXoL3rZ83HFiUFtp/ZkveZKi53ANUaqy5/U5v0Q0Ppz9ujcRA9I/V3B66D KMg1UjiigJG6espeIPjXjw0n9BCa9jqGICyJTIZhnbEs1yEpsM87eUIH/0UFLv0b8IZepL/3 QfiFoYSqMEAwCVDFkCt4uUVFZczKTDXTFkwm7zflvRHdy5QyVFDWMyGnTN+Bq48Gwn1MuRT/ Sg37LIjAUmKRJPDkVr/DQDbyL6rTvNbA3hTBu392v0CXFsvpgRNYaT8oz7DDBUUWj2Ny6bZC Btwr/O+CwVVqWRzKDQgVo4t1xk2ts1F0R1uHHLsX7mIgfXBYdo/y4UgFBAJH5NYUcBR+QQcO gUUZeF2MC9i0oUaHJOIuuN2q+m9eMpnJdxVKAUQcZxDDvNjZwZh+ejsgG4Ejd2XR/T0yXFoR /dLFIhf2zxRylN1xq27M9P2t1xfQFocuYToPsVk= Message-ID: <84bdf20d-6d0e-8075-bf29-651ed946c4bd@harmstone.com> Date: Fri, 18 Sep 2020 19:32:42 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.11.0 MIME-Version: 1.0 In-Reply-To: <20200918162204.3706029-3-almaz.alexandrovich@paragon-software.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Nit-picking a little, but I think S-1-5-7 "Anonymous" would be a better choice for your default SD's owner and group. It implies then to Windows users that Linux hasn't tried to do any uid <-> SID mapping. On 18/9/20 5:21 pm, Konstantin Komarov wrote: > This adds initialization of super block > > Signed-off-by: Konstantin Komarov > --- > fs/ntfs3/fsntfs.c | 2201 +++++++++++++++++++++++++++++++++++++ > fs/ntfs3/index.c | 2639 +++++++++++++++++++++++++++++++++++++++++++++ > fs/ntfs3/inode.c | 1998 ++++++++++++++++++++++++++++++++++ > fs/ntfs3/super.c | 1430 ++++++++++++++++++++++++ > 4 files changed, 8268 insertions(+) > create mode 100644 fs/ntfs3/fsntfs.c > create mode 100644 fs/ntfs3/index.c > create mode 100644 fs/ntfs3/inode.c > create mode 100644 fs/ntfs3/super.c > > diff --git a/fs/ntfs3/fsntfs.c b/fs/ntfs3/fsntfs.c > new file mode 100644 > index 000000000000..1e8fc4cea23a > --- /dev/null > +++ b/fs/ntfs3/fsntfs.c > @@ -0,0 +1,2201 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * linux/fs/ntfs3/fsntfs.c > + * > + * Copyright (C) 2019-2020 Paragon Software GmbH, All rights reserved. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include "debug.h" > +#include "ntfs.h" > +#include "ntfs_fs.h" > + > +const struct cpu_str NAME_MFT = { 4, 0, { '$', 'M', 'F', 'T' } }; > +const struct cpu_str NAME_MIRROR = { 8, > + 0, > + { '$', 'M', 'F', 'T', 'M', 'i', 'r', > + 'r' } }; > +const struct cpu_str NAME_LOGFILE = { 8, > + 0, > + { '$', 'L', 'o', 'g', 'F', 'i', 'l', > + 'e' } }; > +const struct cpu_str NAME_VOLUME = { 7, > + 0, > + { '$', 'V', 'o', 'l', 'u', 'm', 'e' } }; > +const struct cpu_str NAME_ATTRDEF = { 8, > + 0, > + { '$', 'A', 't', 't', 'r', 'D', 'e', > + 'f' } }; > +const struct cpu_str NAME_ROOT = { 1, 0, { '.' } }; > +const struct cpu_str NAME_BITMAP = { 7, > + 0, > + { '$', 'B', 'i', 't', 'm', 'a', 'p' } }; > +const struct cpu_str NAME_BOOT = { 5, 0, { '$', 'B', 'o', 'o', 't' } }; > +const struct cpu_str NAME_BADCLUS = { 8, > + 0, > + { '$', 'B', 'a', 'd', 'C', 'l', 'u', > + 's' } }; > +const struct cpu_str NAME_QUOTA = { 6, 0, { '$', 'Q', 'u', 'o', 't', 'a' } }; > +const struct cpu_str NAME_SECURE = { 7, > + 0, > + { '$', 'S', 'e', 'c', 'u', 'r', 'e' } }; > +const struct cpu_str NAME_UPCASE = { 7, > + 0, > + { '$', 'U', 'p', 'C', 'a', 's', 'e' } }; > +const struct cpu_str NAME_EXTEND = { 7, > + 0, > + { '$', 'E', 'x', 't', 'e', 'n', 'd' } }; > +const struct cpu_str NAME_OBJID = { 6, 0, { '$', 'O', 'b', 'j', 'I', 'd' } }; > +const struct cpu_str NAME_REPARSE = { 8, > + 0, > + { '$', 'R', 'e', 'p', 'a', 'r', 's', > + 'e' } }; > +const struct cpu_str NAME_USNJRNL = { 8, > + 0, > + { '$', 'U', 's', 'n', 'J', 'r', 'n', > + 'l' } }; > +const __le16 BAD_NAME[4] = { cpu_to_le16('$'), cpu_to_le16('B'), > + cpu_to_le16('a'), cpu_to_le16('d') }; > +const __le16 I30_NAME[4] = { cpu_to_le16('$'), cpu_to_le16('I'), > + cpu_to_le16('3'), cpu_to_le16('0') }; > +const __le16 SII_NAME[4] = { cpu_to_le16('$'), cpu_to_le16('S'), > + cpu_to_le16('I'), cpu_to_le16('I') }; > +const __le16 SDH_NAME[4] = { cpu_to_le16('$'), cpu_to_le16('S'), > + cpu_to_le16('D'), cpu_to_le16('H') }; > +const __le16 SDS_NAME[4] = { cpu_to_le16('$'), cpu_to_le16('S'), > + cpu_to_le16('D'), cpu_to_le16('S') }; > +const __le16 SO_NAME[2] = { cpu_to_le16('$'), cpu_to_le16('O') }; > +const __le16 SQ_NAME[2] = { cpu_to_le16('$'), cpu_to_le16('Q') }; > +const __le16 SR_NAME[2] = { cpu_to_le16('$'), cpu_to_le16('R') }; > +//const __le16 EFS_NAME[4] = { '$', 'E', 'F', 'S' }; > + > +//const __le16 WOF_NAME[17] = { 'W', 'o', 'f', 'C', 'o', 'm', 'p', 'r', 'e', > +// 'S', 'S', 'e', 'd', 'D', 'a', 't', 'a' }; > +//const __le16 J_NAME[2] = { '$', 'J' }; > +//const __le16 MAX_NAME[4] = { '$', 'M', 'a', 'x' }; > + > +/* > + * ntfs_fix_pre_write > + * > + * inserts fixups into 'rhdr' before writing to disk > + */ > +bool ntfs_fix_pre_write(struct NTFS_RECORD_HEADER *rhdr, size_t bytes) > +{ > + u16 *fixup, *ptr; > + u16 sample; > + u16 fo = le16_to_cpu(rhdr->fix_off); > + u16 fn = le16_to_cpu(rhdr->fix_num); > + > + if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || > + fn * SECTOR_SIZE > bytes) { > + return false; > + } > + > + /* Get fixup pointer */ > + fixup = Add2Ptr(rhdr, fo); > + > + if (*fixup >= 0x7FFF) > + *fixup = 1; > + else > + *fixup += 1; > + > + sample = *fixup; > + > + ptr = Add2Ptr(rhdr, SECTOR_SIZE - sizeof(short)); > + > + while (fn--) { > + *++fixup = *ptr; > + *ptr = sample; > + ptr += SECTOR_SIZE / sizeof(short); > + } > + return true; > +} > + > +/* > + * ntfs_fix_post_read > + * > + * remove fixups after reading from disk > + * Returns < 0 if error, 0 if ok, 1 if need to update fixups > + */ > +int ntfs_fix_post_read(struct NTFS_RECORD_HEADER *rhdr, size_t bytes, > + bool simple) > +{ > + int ret; > + u16 *fixup, *ptr; > + u16 sample, fo, fn; > + > + fo = le16_to_cpu(rhdr->fix_off); > + fn = simple ? ((bytes >> SECTOR_SHIFT) + 1) : > + le16_to_cpu(rhdr->fix_num); > + > + /* Check errors */ > + if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || > + fn * SECTOR_SIZE > bytes) { > + return -EINVAL; /* native chkntfs returns ok! */ > + } > + > + /* Get fixup pointer */ > + fixup = Add2Ptr(rhdr, fo); > + sample = *fixup; > + ptr = Add2Ptr(rhdr, SECTOR_SIZE - sizeof(short)); > + ret = 0; > + > + while (fn--) { > + /* Test current word */ > + if (*ptr != sample) > + ret = 1; > + > + /* Replace fixup */ > + *ptr = *++fixup; > + ptr += SECTOR_SIZE / sizeof(short); > + } > + > + return ret; > +} > + > +/* > + * ntfs_extend_init > + * > + * loads $Extend file > + */ > +int ntfs_extend_init(struct ntfs_sb_info *sbi) > +{ > + int err; > + struct super_block *sb = sbi->sb; > + struct inode *inode, *inode2; > + struct MFT_REF ref; > + > + if (sbi->volume.major_ver < 3) { > + ntfs_notice(sb, "Skip $Extend 'cause NTFS version"); > + return 0; > + } > + > + ref.low = cpu_to_le32(MFT_REC_EXTEND); > + ref.high = 0; > + ref.seq = cpu_to_le16(MFT_REC_EXTEND); > + inode = ntfs_iget5(sb, &ref, &NAME_EXTEND); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $Extend."); > + inode = NULL; > + goto out; > + } > + > + /* if ntfs_iget5 reads from disk it never returns bad inode */ > + if (!S_ISDIR(inode->i_mode)) { > + err = -EINVAL; > + goto out; > + } > + > + /* Try to find $ObjId */ > + inode2 = dir_search_u(inode, &NAME_OBJID, NULL); > + if (inode2 && !IS_ERR(inode2)) { > + if (is_bad_inode(inode2)) { > + iput(inode2); > + } else { > + sbi->objid.ni = ntfs_i(inode2); > + sbi->objid_no = inode2->i_ino; > + } > + } > + > + /* Try to find $Quota */ > + inode2 = dir_search_u(inode, &NAME_QUOTA, NULL); > + if (inode2 && !IS_ERR(inode2)) { > + sbi->quota_no = inode2->i_ino; > + iput(inode2); > + } > + > + /* Try to find $Reparse */ > + inode2 = dir_search_u(inode, &NAME_REPARSE, NULL); > + if (inode2 && !IS_ERR(inode2)) { > + sbi->reparse.ni = ntfs_i(inode2); > + sbi->reparse_no = inode2->i_ino; > + } > + > + /* Try to find $UsnJrnl */ > + inode2 = dir_search_u(inode, &NAME_USNJRNL, NULL); > + if (inode2 && !IS_ERR(inode2)) { > + sbi->usn_jrnl_no = inode2->i_ino; > + iput(inode2); > + } > + > + err = 0; > +out: > + iput(inode); > + return err; > +} > + > +int ntfs_loadlog_and_replay(struct ntfs_inode *ni, struct ntfs_sb_info *sbi) > +{ > + int err = 0; > + struct super_block *sb = sbi->sb; > + struct inode *inode; > + struct MFT_REF ref; > + u32 idx; > + CLST lcn, len; > + > + inode = &ni->vfs_inode; > + > + /* Check for 4GB */ > + if (inode->i_size >= 0x100000000ull) { > + ntfs_err(sb, "$LogFile is too big"); > + err = -EINVAL; > + goto out; > + } > + > + sbi->flags |= NTFS_FLAGS_LOG_REPLAYING; > + > + ref.low = cpu_to_le32(MFT_REC_MFT); > + ref.high = 0; > + ref.seq = cpu_to_le16(1); > + > + inode = ntfs_iget5(sb, &ref, NULL); > + > + if (IS_ERR(inode)) > + inode = NULL; > + > + if (!inode) { > + /* Try to use mft copy */ > + u64 t64 = sbi->mft.lbo; > + > + sbi->mft.lbo = sbi->mft.lbo2; > + inode = ntfs_iget5(sb, &ref, NULL); > + sbi->mft.lbo = t64; > + if (IS_ERR(inode)) > + inode = NULL; > + } > + > + if (!inode) { > + err = -EINVAL; > + ntfs_err(sb, "Failed to load $MFT."); > + goto out; > + } > + > + sbi->mft.ni = ntfs_i(inode); > + > + err = ni_load_all_mi(sbi->mft.ni); > + if (!err) > + err = log_replay(ni); > + > + iput(inode); > + sbi->mft.ni = NULL; > + > + sync_blockdev(sb->s_bdev); > + invalidate_bdev(sb->s_bdev); > + > + /* reinit MFT */ > + if (sbi->flags & NTFS_FLAGS_NEED_REPLAY) { > + err = 0; > + goto out; > + } > + > + if (sb_rdonly(sb)) > + goto out; > + > + idx = 0; > + while (run_get_entry(&ni->file.run, idx++, NULL, &lcn, &len)) { > + u64 lbo = (u64)lcn << sbi->cluster_bits; > + u64 bytes = (u64)len << sbi->cluster_bits; > + > + err = ntfs_sb_write(sb, lbo, bytes, NULL, 0); > + if (err) > + goto out; > + } > + > +out: > + sbi->flags &= ~NTFS_FLAGS_LOG_REPLAYING; > + > + return err; > +} > + > +/* > + * ntfs_query_def > + * > + * returns current ATTR_DEF_ENTRY for given attribute type > + */ > +const struct ATTR_DEF_ENTRY *ntfs_query_def(struct ntfs_sb_info *sbi, > + enum ATTR_TYPE type) > +{ > + int type_in = le32_to_cpu(type); > + size_t min_idx = 0; > + size_t max_idx = sbi->def_entries - 1; > + > + while (min_idx <= max_idx) { > + size_t i = min_idx + ((max_idx - min_idx) >> 1); > + const struct ATTR_DEF_ENTRY *entry = sbi->def_table + i; > + int diff = le32_to_cpu(entry->type) - type_in; > + > + if (!diff) > + return entry; > + if (diff < 0) > + min_idx = i + 1; > + else if (i) > + max_idx = i - 1; > + else > + return NULL; > + } > + return NULL; > +} > + > +/* > + * ntfs_look_for_free_space > + * > + * looks for a free space in bitmap > + */ > +int ntfs_look_for_free_space(struct ntfs_sb_info *sbi, CLST lcn, CLST len, > + CLST *new_lcn, CLST *new_len, > + enum ALLOCATE_OPT opt) > +{ > + int err; > + struct super_block *sb = sbi->sb; > + size_t a_lcn, zlen, zeroes, zlcn, zlen2, ztrim, new_zlen; > + struct wnd_bitmap *wnd = &sbi->used.bitmap; > + > + down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS); > + if (opt & ALLOCATE_MFT) { > + CLST alen; > + > + zlen = wnd_zone_len(wnd); > + > + if (!zlen) { > + err = ntfs_refresh_zone(sbi); > + if (err) > + goto out; > + > + zlen = wnd_zone_len(wnd); > + > + if (!zlen) { > + ntfs_err(sbi->sb, > + "no free space to extend mft"); > + err = -ENOSPC; > + goto out; > + } > + } > + > + lcn = wnd_zone_bit(wnd); > + alen = zlen > len ? len : zlen; > + > + wnd_zone_set(wnd, lcn + alen, zlen - alen); > + > + err = wnd_set_used(wnd, lcn, alen); > + if (err) > + goto out; > + > + *new_lcn = lcn; > + *new_len = alen; > + goto ok; > + } > + > + /* > + * 'Cause cluster 0 is always used this value means that we should use > + * cached value of 'next_free_lcn' to improve performance > + */ > + if (!lcn) > + lcn = sbi->used.next_free_lcn; > + > + if (lcn >= wnd->nbits) > + lcn = 0; > + > + *new_len = wnd_find(wnd, len, lcn, BITMAP_FIND_MARK_AS_USED, &a_lcn); > + if (*new_len) { > + *new_lcn = a_lcn; > + goto ok; > + } > + > + /* Try to use clusters from MftZone */ > + zlen = wnd_zone_len(wnd); > + zeroes = wnd_zeroes(wnd); > + > + /* Check too big request */ > + if (len > zeroes + zlen) > + goto no_space; > + > + if (zlen <= NTFS_MIN_MFT_ZONE) > + goto no_space; > + > + /* How many clusters to cat from zone */ > + zlcn = wnd_zone_bit(wnd); > + zlen2 = zlen >> 1; > + ztrim = len > zlen ? zlen : (len > zlen2 ? len : zlen2); > + new_zlen = zlen - ztrim; > + > + if (new_zlen < NTFS_MIN_MFT_ZONE) { > + new_zlen = NTFS_MIN_MFT_ZONE; > + if (new_zlen > zlen) > + new_zlen = zlen; > + } > + > + wnd_zone_set(wnd, zlcn, new_zlen); > + > + /* allocate continues clusters */ > + *new_len = > + wnd_find(wnd, len, 0, > + BITMAP_FIND_MARK_AS_USED | BITMAP_FIND_FULL, &a_lcn); > + if (*new_len) { > + *new_lcn = a_lcn; > + goto ok; > + } > + > +no_space: > + up_write(&wnd->rw_lock); > + > + return -ENOSPC; > + > +ok: > + err = 0; > + > + ntfs_unmap_meta(sb, *new_lcn, *new_len); > + > + if (opt & ALLOCATE_MFT) > + goto out; > + > + /* Set hint for next requests */ > + sbi->used.next_free_lcn = *new_lcn + *new_len; > + > +out: > + up_write(&wnd->rw_lock); > + return err; > +} > + > +/* > + * ntfs_extend_mft > + * > + * allocates additional MFT records > + * sbi->mft.bitmap is locked for write > + * > + * NOTE: recursive: > + * ntfs_look_free_mft -> > + * ntfs_extend_mft -> > + * attr_set_size -> > + * ni_insert_nonresident -> > + * ni_insert_attr -> > + * ni_ins_attr_ext -> > + * ntfs_look_free_mft -> > + * ntfs_extend_mft > + * To avoid recursive always allocate space for two new mft records > + * see attrib.c: "at least two mft to avoid recursive loop" > + */ > +static int ntfs_extend_mft(struct ntfs_sb_info *sbi) > +{ > + int err; > + struct ntfs_inode *ni = sbi->mft.ni; > + size_t new_mft_total; > + u64 new_mft_bytes, new_bitmap_bytes; > + struct ATTRIB *attr; > + struct wnd_bitmap *wnd = &sbi->mft.bitmap; > + > + new_mft_total = (wnd->nbits + MFT_INCREASE_CHUNK + 127) & (CLST)~127; > + new_mft_bytes = (u64)new_mft_total << sbi->record_bits; > + > + /* Step 1: Resize $MFT::DATA */ > + down_write(&ni->file.run_lock); > + err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, > + new_mft_bytes, NULL, false, &attr); > + > + if (err) { > + up_write(&ni->file.run_lock); > + goto out; > + } > + > + attr->nres.valid_size = attr->nres.data_size; > + new_mft_total = le64_to_cpu(attr->nres.alloc_size) >> sbi->record_bits; > + ni->mi.dirty = true; > + > + /* Step 2: Resize $MFT::BITMAP */ > + new_bitmap_bytes = bitmap_size(new_mft_total); > + > + err = attr_set_size(ni, ATTR_BITMAP, NULL, 0, &sbi->mft.bitmap.run, > + new_bitmap_bytes, &new_bitmap_bytes, true, NULL); > + > + /* Refresh Mft Zone if necessary */ > + down_write_nested(&sbi->used.bitmap.rw_lock, BITMAP_MUTEX_CLUSTERS); > + > + ntfs_refresh_zone(sbi); > + > + up_write(&sbi->used.bitmap.rw_lock); > + up_write(&ni->file.run_lock); > + > + if (err) > + goto out; > + > + err = wnd_extend(wnd, new_mft_total); > + > + if (err) > + goto out; > + > + ntfs_clear_mft_tail(sbi, sbi->mft.used, new_mft_total); > + > + err = _ni_write_inode(&ni->vfs_inode, 0); > +out: > + return err; > +} > + > +/* > + * ntfs_look_free_mft > + * > + * looks for a free MFT record > + */ > +int ntfs_look_free_mft(struct ntfs_sb_info *sbi, CLST *rno, bool mft, > + struct ntfs_inode *ni, struct mft_inode **mi) > +{ > + int err = 0; > + size_t zbit, zlen, from, to, fr; > + size_t mft_total; > + struct MFT_REF ref; > + struct super_block *sb = sbi->sb; > + struct wnd_bitmap *wnd = &sbi->mft.bitmap; > + u32 ir; > + > + static_assert(sizeof(sbi->mft.reserved_bitmap) * 8 >= > + MFT_REC_FREE - MFT_REC_RESERVED); > + > + if (!mft) > + down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT); > + > + zlen = wnd_zone_len(wnd); > + > + /* Always reserve space for MFT */ > + if (zlen) { > + if (mft) { > + zbit = wnd_zone_bit(wnd); > + *rno = zbit; > + wnd_zone_set(wnd, zbit + 1, zlen - 1); > + } > + goto found; > + } > + > + /* No MFT zone. find the nearest to '0' free MFT */ > + if (!wnd_find(wnd, 1, MFT_REC_FREE, 0, &zbit)) { > + /* Resize MFT */ > + mft_total = wnd->nbits; > + > + err = ntfs_extend_mft(sbi); > + if (!err) { > + zbit = mft_total; > + goto reserve_mft; > + } > + > + if (!mft || MFT_REC_FREE == sbi->mft.next_reserved) > + goto out; > + > + err = 0; > + > + /* > + * Look for free record reserved area [11-16) == > + * [MFT_REC_RESERVED, MFT_REC_FREE ) MFT bitmap always > + * marks it as used > + */ > + if (!sbi->mft.reserved_bitmap) { > + /* Once per session create internal bitmap for 5 bits */ > + sbi->mft.reserved_bitmap = 0xFF; > + > + ref.high = 0; > + for (ir = MFT_REC_RESERVED; ir < MFT_REC_FREE; ir++) { > + struct inode *i; > + struct ntfs_inode *ni; > + struct MFT_REC *mrec; > + > + ref.low = cpu_to_le32(ir); > + ref.seq = cpu_to_le16(ir); > + > + i = ntfs_iget5(sb, &ref, NULL); > + if (IS_ERR(i)) { > +next: > + ntfs_notice( > + sb, > + "Invalid reserved record %x", > + ref.low); > + continue; > + } > + if (is_bad_inode(i)) { > + iput(i); > + goto next; > + } > + > + ni = ntfs_i(i); > + > + mrec = ni->mi.mrec; > + > + if (!is_rec_base(mrec)) > + goto next; > + > + if (mrec->hard_links) > + goto next; > + > + if (!ni_std(ni)) > + goto next; > + > + if (ni_find_attr(ni, NULL, NULL, ATTR_NAME, > + NULL, 0, NULL, NULL)) > + goto next; > + > + __clear_bit(ir - MFT_REC_RESERVED, > + &sbi->mft.reserved_bitmap); > + } > + } > + > + /* Scan 5 bits for zero. Bit 0 == MFT_REC_RESERVED */ > + zbit = find_next_zero_bit(&sbi->mft.reserved_bitmap, > + MFT_REC_FREE, MFT_REC_RESERVED); > + if (zbit >= MFT_REC_FREE) { > + sbi->mft.next_reserved = MFT_REC_FREE; > + goto out; > + } > + > + zlen = 1; > + sbi->mft.next_reserved = zbit; > + } else { > +reserve_mft: > + zlen = zbit == MFT_REC_FREE ? (MFT_REC_USER - MFT_REC_FREE) : 4; > + if (zbit + zlen > wnd->nbits) > + zlen = wnd->nbits - zbit; > + > + while (zlen > 1 && !wnd_is_free(wnd, zbit, zlen)) > + zlen -= 1; > + > + /* [zbit, zbit + zlen) will be used for Mft itself */ > + from = sbi->mft.used; > + if (from < zbit) > + from = zbit; > + to = zbit + zlen; > + if (from < to) { > + ntfs_clear_mft_tail(sbi, from, to); > + sbi->mft.used = to; > + } > + } > + > + if (mft) { > + *rno = zbit; > + zbit += 1; > + zlen -= 1; > + } > + > + wnd_zone_set(wnd, zbit, zlen); > + > +found: > + if (!mft) { > + /* The request to get record for general purpose */ > + if (sbi->mft.next_free < MFT_REC_USER) > + sbi->mft.next_free = MFT_REC_USER; > + > + for (;;) { > + if (sbi->mft.next_free >= sbi->mft.bitmap.nbits) { > + } else if (!wnd_find(wnd, 1, MFT_REC_USER, 0, &fr)) { > + sbi->mft.next_free = sbi->mft.bitmap.nbits; > + } else { > + *rno = fr; > + sbi->mft.next_free = *rno + 1; > + break; > + } > + > + err = ntfs_extend_mft(sbi); > + if (err) > + goto out; > + } > + } > + > + if (ni && !ni_add_subrecord(ni, *rno, mi)) { > + err = -ENOMEM; > + goto out; > + } > + > + /* We have found a record that are not reserved for next MFT */ > + if (*rno >= MFT_REC_FREE) > + wnd_set_used(wnd, *rno, 1); > + else if (*rno >= MFT_REC_RESERVED && sbi->mft.reserved_bitmap_inited) > + __set_bit(*rno - MFT_REC_RESERVED, &sbi->mft.reserved_bitmap); > + > +out: > + if (!mft) > + up_write(&wnd->rw_lock); > + > + return err; > +} > + > +/* > + * ntfs_mark_rec_free > + * > + * marks record as free > + */ > +void ntfs_mark_rec_free(struct ntfs_sb_info *sbi, CLST rno) > +{ > + struct wnd_bitmap *wnd = &sbi->mft.bitmap; > + > + down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_MFT); > + if (rno >= wnd->nbits) > + goto out; > + > + if (rno >= MFT_REC_FREE) { > + if (!wnd_is_used(wnd, rno, 1)) > + ntfs_set_state(sbi, NTFS_DIRTY_ERROR); > + else > + wnd_set_free(wnd, rno, 1); > + } else if (rno >= MFT_REC_RESERVED && sbi->mft.reserved_bitmap_inited) { > + __clear_bit(rno - MFT_REC_RESERVED, &sbi->mft.reserved_bitmap); > + } > + > + if (rno < wnd_zone_bit(wnd)) > + wnd_zone_set(wnd, rno, 1); > + else if (rno < sbi->mft.next_free && rno >= MFT_REC_USER) > + sbi->mft.next_free = rno; > + > +out: > + up_write(&wnd->rw_lock); > +} > + > +/* > + * ntfs_clear_mft_tail > + * > + * formats empty records [from, to) > + * sbi->mft.bitmap is locked for write > + */ > +int ntfs_clear_mft_tail(struct ntfs_sb_info *sbi, size_t from, size_t to) > +{ > + int err; > + u32 rs; > + u64 vbo; > + struct runs_tree *run; > + struct ntfs_inode *ni; > + > + if (from >= to) > + return 0; > + > + rs = sbi->record_size; > + ni = sbi->mft.ni; > + run = &ni->file.run; > + > + down_read(&ni->file.run_lock); > + vbo = (u64)from * rs; > + for (; from < to; from++, vbo += rs) { > + struct ntfs_buffers nb; > + > + err = ntfs_get_bh(sbi, run, vbo, rs, &nb); > + if (err) > + goto out; > + > + err = ntfs_write_bh(sbi, &sbi->new_rec->rhdr, &nb, 0); > + nb_put(&nb); > + if (err) > + goto out; > + } > + > +out: > + sbi->mft.used = from; > + up_read(&ni->file.run_lock); > + return err; > +} > + > +/* > + * ntfs_refresh_zone > + * > + * refreshes Mft zone > + * sbi->used.bitmap is locked for rw > + * sbi->mft.bitmap is locked for write > + * sbi->mft.ni->file.run_lock for write > + */ > +int ntfs_refresh_zone(struct ntfs_sb_info *sbi) > +{ > + CLST zone_limit, zone_max, lcn, vcn, len; > + size_t lcn_s, zlen; > + struct wnd_bitmap *wnd = &sbi->used.bitmap; > + struct ntfs_inode *ni = sbi->mft.ni; > + > + /* Do not change anything unless we have non empty Mft zone */ > + if (wnd_zone_len(wnd)) > + return 0; > + > + /* > + * Compute the mft zone at two steps > + * It would be nice if we are able to allocate > + * 1/8 of total clusters for MFT but not more then 512 MB > + */ > + zone_limit = (512 * 1024 * 1024) >> sbi->cluster_bits; > + zone_max = wnd->nbits >> 3; > + if (zone_max > zone_limit) > + zone_max = zone_limit; > + > + vcn = bytes_to_cluster(sbi, > + (u64)sbi->mft.bitmap.nbits << sbi->record_bits); > + > + if (!run_lookup_entry(&ni->file.run, vcn - 1, &lcn, &len, NULL)) > + lcn = SPARSE_LCN; > + > + /* We should always find Last Lcn for MFT */ > + if (lcn == SPARSE_LCN) > + return -EINVAL; > + > + lcn_s = lcn + 1; > + > + /* Try to allocate clusters after last MFT run */ > + zlen = wnd_find(wnd, zone_max, lcn_s, 0, &lcn_s); > + if (!zlen) { > + ntfs_notice(sbi->sb, "MftZone: unavailable"); > + return 0; > + } > + > + /* Truncate too large zone */ > + wnd_zone_set(wnd, lcn_s, zlen); > + > + return 0; > +} > + > +/* > + * ntfs_update_mftmirr > + * > + * updates $MFTMirr data > + */ > +int ntfs_update_mftmirr(struct ntfs_sb_info *sbi, int wait) > +{ > + int err; > + struct super_block *sb = sbi->sb; > + u32 blocksize = sb->s_blocksize; > + sector_t block1, block2; > + u32 bytes; > + > + if (!(sbi->flags & NTFS_FLAGS_MFTMIRR)) > + return 0; > + > + err = 0; > + bytes = sbi->mft.recs_mirr << sbi->record_bits; > + block1 = sbi->mft.lbo >> sb->s_blocksize_bits; > + block2 = sbi->mft.lbo2 >> sb->s_blocksize_bits; > + > + for (; bytes >= blocksize; bytes -= blocksize) { > + struct buffer_head *bh1, *bh2; > + > + bh1 = sb_bread(sb, block1++); > + if (!bh1) { > + err = -EIO; > + goto out; > + } > + > + bh2 = sb_getblk(sb, block2++); > + if (!bh2) { > + put_bh(bh1); > + err = -EIO; > + goto out; > + } > + > + if (buffer_locked(bh2)) > + __wait_on_buffer(bh2); > + > + lock_buffer(bh2); > + memcpy(bh2->b_data, bh1->b_data, blocksize); > + set_buffer_uptodate(bh2); > + mark_buffer_dirty(bh2); > + unlock_buffer(bh2); > + > + put_bh(bh1); > + bh1 = NULL; > + > + if (wait) > + err = sync_dirty_buffer(bh2); > + > + put_bh(bh2); > + if (err) > + goto out; > + } > + > + sbi->flags &= ~NTFS_FLAGS_MFTMIRR; > + > +out: > + return err; > +} > + > +/* > + * ntfs_set_state > + * > + * mount: ntfs_set_state(NTFS_DIRTY_DIRTY) > + * umount: ntfs_set_state(NTFS_DIRTY_CLEAR) > + * ntfs error: ntfs_set_state(NTFS_DIRTY_ERROR) > + */ > +int ntfs_set_state(struct ntfs_sb_info *sbi, enum NTFS_DIRTY_FLAGS dirty) > +{ > + int err; > + struct ATTRIB *attr; > + struct VOLUME_INFO *info; > + struct mft_inode *mi; > + struct ntfs_inode *ni; > + > + /* > + * do not change state if fs was real_dirty > + * do not change state if fs already dirty(clear) > + * do not change any thing if mounted read only > + */ > + if (sbi->volume.real_dirty || sb_rdonly(sbi->sb)) > + return 0; > + > + /* Check cached value */ > + if ((dirty == NTFS_DIRTY_CLEAR ? 0 : VOLUME_FLAG_DIRTY) == > + (sbi->volume.flags & VOLUME_FLAG_DIRTY)) > + return 0; > + > + ni = sbi->volume.ni; > + if (!ni) > + return -EINVAL; > + > + inode_lock(&ni->vfs_inode); > + > + attr = ni_find_attr(ni, NULL, NULL, ATTR_VOL_INFO, NULL, 0, NULL, &mi); > + if (!attr) { > + err = -EINVAL; > + goto out; > + } > + > + info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO); > + if (!info) { > + err = -EINVAL; > + goto out; > + } > + > + switch (dirty) { > + case NTFS_DIRTY_ERROR: > + ntfs_notice(sbi->sb, "Mark volume as dirty due to NTFS errors"); > + sbi->volume.real_dirty = true; > + fallthrough; > + case NTFS_DIRTY_DIRTY: > + info->flags |= VOLUME_FLAG_DIRTY; > + break; > + case NTFS_DIRTY_CLEAR: > + info->flags &= ~VOLUME_FLAG_DIRTY; > + break; > + } > + /* cache current volume flags*/ > + sbi->volume.flags = info->flags; > + mi->dirty = true; > + err = 0; > + > +out: > + inode_unlock(&ni->vfs_inode); > + if (err) > + return err; > + > + mark_inode_dirty(&ni->vfs_inode); > + /*verify(!ntfs_update_mftmirr()); */ > + err = sync_inode_metadata(&ni->vfs_inode, 1); > + > + return err; > +} > + > +/* > + * security_hash > + * > + * calculates a hash of security descriptor > + */ > +static inline __le32 security_hash(const void *sd, size_t bytes) > +{ > + u32 hash = 0; > + const __le32 *ptr = sd; > + > + bytes >>= 2; > + while (bytes--) > + hash = ((hash >> 0x1D) | (hash << 3)) + le32_to_cpu(*ptr++); > + return cpu_to_le32(hash); > +} > + > +int ntfs_sb_read(struct super_block *sb, u64 lbo, size_t bytes, void *buffer) > +{ > + struct block_device *bdev = sb->s_bdev; > + u32 blocksize = sb->s_blocksize; > + u64 block = lbo >> sb->s_blocksize_bits; > + u32 off = lbo & (blocksize - 1); > + u32 op = blocksize - off; > + > + for (; bytes; block += 1, off = 0, op = blocksize) { > + struct buffer_head *bh = __bread(bdev, block, blocksize); > + > + if (!bh) > + return -EIO; > + > + if (op > bytes) > + op = bytes; > + > + memcpy(buffer, bh->b_data + off, op); > + > + put_bh(bh); > + > + bytes -= op; > + buffer = Add2Ptr(buffer, op); > + } > + > + return 0; > +} > + > +int ntfs_sb_write(struct super_block *sb, u64 lbo, size_t bytes, > + const void *buf, int wait) > +{ > + u32 blocksize = sb->s_blocksize; > + struct block_device *bdev = sb->s_bdev; > + sector_t block = lbo >> sb->s_blocksize_bits; > + u32 off = lbo & (blocksize - 1); > + u32 op = blocksize - off; > + struct buffer_head *bh; > + > + if (!wait && (sb->s_flags & SB_SYNCHRONOUS)) > + wait = 1; > + > + for (; bytes; block += 1, off = 0, op = blocksize) { > + if (op > bytes) > + op = bytes; > + > + if (op < blocksize) { > + bh = __bread(bdev, block, blocksize); > + if (!bh) { > + ntfs_err(sb, "failed to read block %llx", > + (u64)block); > + return -EIO; > + } > + } else { > + bh = __getblk(bdev, block, blocksize); > + if (!bh) > + return -ENOMEM; > + } > + > + if (buffer_locked(bh)) > + __wait_on_buffer(bh); > + > + lock_buffer(bh); > + if (buf) { > + memcpy(bh->b_data + off, buf, op); > + buf = Add2Ptr(buf, op); > + } else { > + memset(bh->b_data + off, -1, op); > + } > + > + set_buffer_uptodate(bh); > + mark_buffer_dirty(bh); > + unlock_buffer(bh); > + > + if (wait) { > + int err = sync_dirty_buffer(bh); > + > + if (err) { > + ntfs_err( > + sb, > + "failed to sync buffer at block %llx, error %d", > + (u64)block, err); > + put_bh(bh); > + return err; > + } > + } > + > + put_bh(bh); > + > + bytes -= op; > + } > + return 0; > +} > + > +int ntfs_sb_write_run(struct ntfs_sb_info *sbi, struct runs_tree *run, u64 vbo, > + const void *buf, size_t bytes) > +{ > + struct super_block *sb = sbi->sb; > + u8 cluster_bits = sbi->cluster_bits; > + u32 off = vbo & sbi->cluster_mask; > + CLST lcn, clen; > + u64 lbo, len; > + size_t idx; > + > + if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &clen, &idx)) > + return -ENOENT; > + > + if (lcn == SPARSE_LCN) > + return -EINVAL; > + > + lbo = ((u64)lcn << cluster_bits) + off; > + len = ((u64)clen << cluster_bits) - off; > + > + for (;;) { > + u32 op = len < bytes ? len : bytes; > + int err = ntfs_sb_write(sb, lbo, op, buf, 0); > + > + if (err) > + return err; > + > + bytes -= op; > + if (!bytes) > + break; > + > + if (!run_get_entry(run, ++idx, NULL, &lcn, &clen)) > + return -ENOENT; > + > + if (lcn == SPARSE_LCN) > + return -EINVAL; > + > + if (buf) > + buf = Add2Ptr(buf, op); > + > + lbo = ((u64)lcn << cluster_bits) + off; > + len = ((u64)clen << cluster_bits) - off; > + } > + > + return 0; > +} > + > +struct buffer_head *ntfs_bread_run(struct ntfs_sb_info *sbi, > + struct runs_tree *run, u64 vbo) > +{ > + struct super_block *sb = sbi->sb; > + u8 cluster_bits = sbi->cluster_bits; > + CLST lcn; > + u64 lbo; > + > + if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, NULL, NULL)) > + return ERR_PTR(-ENOENT); > + > + lbo = ((u64)lcn << cluster_bits) + (vbo & sbi->cluster_mask); > + > + return ntfs_bread(sb, lbo >> sb->s_blocksize_bits); > +} > + > +int ntfs_read_run_nb(struct ntfs_sb_info *sbi, struct runs_tree *run, u64 vbo, > + void *buf, u32 bytes, struct ntfs_buffers *nb) > +{ > + int err; > + struct super_block *sb = sbi->sb; > + u32 blocksize = sb->s_blocksize; > + u8 cluster_bits = sbi->cluster_bits; > + u32 off = vbo & sbi->cluster_mask; > + u32 nbh = 0; > + CLST lcn, clen; > + u64 lbo, len; > + size_t idx; > + struct buffer_head *bh; > + > + if (!run) { > + /* first reading of $Volume + $MFTMirr + $LogFile goes here*/ > + if (vbo > MFT_REC_VOL * sbi->record_size) { > + err = -ENOENT; > + goto out; > + } > + > + /* use absolute boot's 'MFTCluster' to read record */ > + lbo = vbo + sbi->mft.lbo; > + len = sbi->record_size; > + } else if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &clen, > + &idx)) { > + err = -ENOENT; > + goto out; > + } else { > + if (lcn == SPARSE_LCN) { > + err = -EINVAL; > + goto out; > + } > + > + lbo = ((u64)lcn << cluster_bits) + off; > + len = ((u64)clen << cluster_bits) - off; > + } > + > + off = lbo & (blocksize - 1); > + if (nb) { > + nb->off = off; > + nb->bytes = bytes; > + } > + > + for (;;) { > + u32 len32 = len >= bytes ? bytes : len; > + sector_t block = lbo >> sb->s_blocksize_bits; > + > + do { > + u32 op = blocksize - off; > + > + if (op > len32) > + op = len32; > + > + bh = ntfs_bread(sb, block); > + if (!bh) { > + err = -EIO; > + goto out; > + } > + > + if (buf) { > + memcpy(buf, bh->b_data + off, op); > + buf = Add2Ptr(buf, op); > + } > + > + if (!nb) { > + put_bh(bh); > + } else if (nbh >= ARRAY_SIZE(nb->bh)) { > + err = -EINVAL; > + goto out; > + } else { > + nb->bh[nbh++] = bh; > + nb->nbufs = nbh; > + } > + > + bytes -= op; > + if (!bytes) > + return 0; > + len32 -= op; > + block += 1; > + off = 0; > + > + } while (len32); > + > + if (!run_get_entry(run, ++idx, NULL, &lcn, &clen)) { > + err = -ENOENT; > + goto out; > + } > + > + if (lcn == SPARSE_LCN) { > + err = -EINVAL; > + goto out; > + } > + > + lbo = ((u64)lcn << cluster_bits); > + len = ((u64)clen << cluster_bits); > + } > + > +out: > + if (!nbh) > + return err; > + > + while (nbh) { > + put_bh(nb->bh[--nbh]); > + nb->bh[nbh] = NULL; > + } > + > + nb->nbufs = 0; > + return err; > +} > + > +/* Returns < 0 if error, 0 if ok, 1 if need to update fixups */ > +int ntfs_read_bh(struct ntfs_sb_info *sbi, struct runs_tree *run, u64 vbo, > + struct NTFS_RECORD_HEADER *rhdr, u32 bytes, > + struct ntfs_buffers *nb) > +{ > + int err = ntfs_read_run_nb(sbi, run, vbo, rhdr, bytes, nb); > + > + if (err) > + return err; > + return ntfs_fix_post_read(rhdr, nb->bytes, true); > +} > + > +int ntfs_get_bh(struct ntfs_sb_info *sbi, struct runs_tree *run, u64 vbo, > + u32 bytes, struct ntfs_buffers *nb) > +{ > + int err = 0; > + struct super_block *sb = sbi->sb; > + u32 blocksize = sb->s_blocksize; > + u8 cluster_bits = sbi->cluster_bits; > + u32 off; > + u32 nbh = 0; > + CLST lcn, clen; > + u64 lbo, len; > + size_t idx; > + > + nb->bytes = bytes; > + > + if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &clen, &idx)) { > + err = -ENOENT; > + goto out; > + } > + > + off = vbo & sbi->cluster_mask; > + lbo = ((u64)lcn << cluster_bits) + off; > + len = ((u64)clen << cluster_bits) - off; > + > + nb->off = off = lbo & (blocksize - 1); > + > + for (;;) { > + u32 len32 = len < bytes ? len : bytes; > + sector_t block = lbo >> sb->s_blocksize_bits; > + > + do { > + u32 op; > + struct buffer_head *bh; > + > + if (nbh >= ARRAY_SIZE(nb->bh)) { > + err = -EINVAL; > + goto out; > + } > + > + op = blocksize - off; > + if (op > len32) > + op = len32; > + > + if (op == blocksize) { > + bh = sb_getblk(sb, block); > + if (!bh) { > + err = -ENOMEM; > + goto out; > + } > + if (buffer_locked(bh)) > + __wait_on_buffer(bh); > + set_buffer_uptodate(bh); > + } else { > + bh = ntfs_bread(sb, block); > + if (!bh) { > + err = -EIO; > + goto out; > + } > + } > + > + nb->bh[nbh++] = bh; > + bytes -= op; > + if (!bytes) { > + nb->nbufs = nbh; > + return 0; > + } > + > + block += 1; > + len32 -= op; > + off = 0; > + } while (len32); > + > + if (!run_get_entry(run, ++idx, NULL, &lcn, &clen)) { > + err = -ENOENT; > + goto out; > + } > + > + lbo = ((u64)lcn << cluster_bits); > + len = ((u64)clen << cluster_bits); > + } > + > +out: > + while (nbh) { > + put_bh(nb->bh[--nbh]); > + nb->bh[nbh] = NULL; > + } > + > + nb->nbufs = 0; > + > + return err; > +} > + > +int ntfs_write_bh(struct ntfs_sb_info *sbi, struct NTFS_RECORD_HEADER *rhdr, > + struct ntfs_buffers *nb, int sync) > +{ > + int err = 0; > + struct super_block *sb = sbi->sb; > + u32 block_size = sb->s_blocksize; > + u32 bytes = nb->bytes; > + u32 off = nb->off; > + u16 fo = le16_to_cpu(rhdr->fix_off); > + u16 fn = le16_to_cpu(rhdr->fix_num); > + u32 idx; > + __le16 *fixup; > + __le16 sample; > + > + if ((fo & 1) || fo + fn * sizeof(short) > SECTOR_SIZE || !fn-- || > + fn * SECTOR_SIZE > bytes) { > + return -EINVAL; > + } > + > + for (idx = 0; bytes && idx < nb->nbufs; idx += 1, off = 0) { > + u32 op = block_size - off; > + char *bh_data; > + struct buffer_head *bh = nb->bh[idx]; > + __le16 *ptr, *end_data; > + > + if (op > bytes) > + op = bytes; > + > + if (buffer_locked(bh)) > + __wait_on_buffer(bh); > + > + lock_buffer(nb->bh[idx]); > + > + bh_data = bh->b_data + off; > + end_data = Add2Ptr(bh_data, op); > + memcpy(bh_data, rhdr, op); > + > + if (!idx) { > + u16 t16; > + > + fixup = Add2Ptr(bh_data, fo); > + sample = *fixup; > + t16 = le16_to_cpu(sample); > + if (t16 >= 0x7FFF) { > + sample = *fixup = cpu_to_le16(1); > + } else { > + sample = cpu_to_le16(t16 + 1); > + *fixup = sample; > + } > + > + *(__le16 *)Add2Ptr(rhdr, fo) = sample; > + } > + > + ptr = Add2Ptr(bh_data, SECTOR_SIZE - sizeof(short)); > + > + do { > + *++fixup = *ptr; > + *ptr = sample; > + ptr += SECTOR_SIZE / sizeof(short); > + } while (ptr < end_data); > + > + set_buffer_uptodate(bh); > + mark_buffer_dirty(bh); > + unlock_buffer(bh); > + > + if (sync) { > + int err2 = sync_dirty_buffer(bh); > + > + if (!err && err2) > + err = err2; > + } > + > + bytes -= op; > + rhdr = Add2Ptr(rhdr, op); > + } > + > + return err; > +} > + > +int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, struct runs_tree *run, u64 vbo, > + u64 *lbo, u64 *bytes) > +{ > + u32 off; > + CLST lcn, len; > + u8 cluster_bits = sbi->cluster_bits; > + > + if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &len, NULL)) > + return -ENOENT; > + > + off = vbo & sbi->cluster_mask; > + *lbo = lcn == SPARSE_LCN ? -1 : (((u64)lcn << cluster_bits) + off); > + *bytes = ((u64)len << cluster_bits) - off; > + > + return 0; > +} > + > +struct ntfs_inode *ntfs_new_inode(struct ntfs_sb_info *sbi, CLST rno, bool dir) > +{ > + int err = 0; > + struct super_block *sb = sbi->sb; > + struct inode *inode = new_inode(sb); > + struct ntfs_inode *ni; > + > + if (!inode) > + return ERR_PTR(-ENOMEM); > + > + ni = ntfs_i(inode); > + > + err = mi_format_new(&ni->mi, sbi, rno, dir ? RECORD_FLAG_DIR : 0, > + false); > + if (err) > + goto out; > + > + inode->i_ino = rno; > + if (insert_inode_locked(inode) < 0) { > + err = -EIO; > + goto out; > + } > + > +out: > + if (err) { > + iput(inode); > + ni = ERR_PTR(err); > + } > + return ni; > +} > + > +/* > + * O:BAG:BAD:(A;OICI;FA;;;WD) > + * owner S-1-5-32-544 (Administrators) > + * group S-1-5-32-544 (Administrators) > + * ACE: allow S-1-1-0 (Everyone) with FILE_ALL_ACCESS > + */ > +const u8 s_default_security[] __aligned(8) = { > + 0x01, 0x00, 0x04, 0x80, 0x30, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1C, 0x00, > + 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x14, 0x00, 0xFF, 0x01, 0x1F, 0x00, > + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, > + 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x20, 0x00, 0x00, 0x00, > + 0x20, 0x02, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, > + 0x20, 0x00, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, > +}; > + > +static_assert(sizeof(s_default_security) == 0x50); > + > +/* > + * ntfs_security_init > + * > + * loads and parse $Secure > + */ > +int ntfs_security_init(struct ntfs_sb_info *sbi) > +{ > + int err; > + struct super_block *sb = sbi->sb; > + struct inode *inode; > + struct ntfs_inode *ni; > + struct MFT_REF ref; > + struct ATTRIB *attr; > + struct ATTR_LIST_ENTRY *le; > + u64 sds_size; > + size_t cnt, off; > + struct NTFS_DE *ne; > + struct NTFS_DE_SII *sii_e; > + struct ntfs_fnd *fnd_sii = NULL; > + const struct INDEX_ROOT *root_sii; > + const struct INDEX_ROOT *root_sdh; > + struct ntfs_index *indx_sdh = &sbi->security.index_sdh; > + struct ntfs_index *indx_sii = &sbi->security.index_sii; > + > + ref.low = cpu_to_le32(MFT_REC_SECURE); > + ref.high = 0; > + ref.seq = cpu_to_le16(MFT_REC_SECURE); > + > + inode = ntfs_iget5(sb, &ref, &NAME_SECURE); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $Secure."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + le = NULL; > + > + attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SDH_NAME, > + ARRAY_SIZE(SDH_NAME), NULL, NULL); > + if (!attr) { > + err = -EINVAL; > + goto out; > + } > + > + root_sdh = resident_data(attr); > + if (root_sdh->type != ATTR_ZERO || > + root_sdh->rule != NTFS_COLLATION_TYPE_SECURITY_HASH) { > + err = -EINVAL; > + goto out; > + } > + > + err = indx_init(indx_sdh, sbi, attr, INDEX_MUTEX_SDH); > + if (err) > + goto out; > + > + attr = ni_find_attr(ni, attr, &le, ATTR_ROOT, SII_NAME, > + ARRAY_SIZE(SII_NAME), NULL, NULL); > + if (!attr) { > + err = -EINVAL; > + goto out; > + } > + > + root_sii = resident_data(attr); > + if (root_sii->type != ATTR_ZERO || > + root_sii->rule != NTFS_COLLATION_TYPE_UINT) { > + err = -EINVAL; > + goto out; > + } > + > + err = indx_init(indx_sii, sbi, attr, INDEX_MUTEX_SII); > + if (err) > + goto out; > + > + fnd_sii = fnd_get(indx_sii); > + if (!fnd_sii) { > + err = -ENOMEM; > + goto out; > + } > + > + sds_size = inode->i_size; > + > + /* Find the last valid Id */ > + sbi->security.next_id = SECURITY_ID_FIRST; > + /* Always write new security at the end of bucket */ > + sbi->security.next_off = > + Quad2Align(sds_size - SecurityDescriptorsBlockSize); > + > + cnt = 0; > + off = 0; > + ne = NULL; > + > + for (;;) { > + u32 next_id; > + > + err = indx_find_raw(indx_sii, ni, root_sii, &ne, &off, fnd_sii); > + if (err || !ne) > + break; > + > + sii_e = (struct NTFS_DE_SII *)ne; > + if (le16_to_cpu(ne->View.data_size) < SIZEOF_SECURITY_HDR) > + continue; > + > + next_id = le32_to_cpu(sii_e->sec_id) + 1; > + if (next_id >= sbi->security.next_id) > + sbi->security.next_id = next_id; > + > + cnt += 1; > + } > + > + sbi->security.ni = ni; > + inode = NULL; > +out: > + iput(inode); > + fnd_put(fnd_sii); > + > + return err; > +} > + > +/* > + * ntfs_get_security_by_id > + * > + * reads security descriptor by id > + */ > +int ntfs_get_security_by_id(struct ntfs_sb_info *sbi, __le32 security_id, > + void **sd, size_t *size) > +{ > + int err; > + int diff; > + struct ntfs_inode *ni = sbi->security.ni; > + struct ntfs_index *indx = &sbi->security.index_sii; > + void *p = NULL; > + struct NTFS_DE_SII *sii_e; > + struct ntfs_fnd *fnd_sii; > + struct SECURITY_HDR d_security; > + const struct INDEX_ROOT *root_sii; > + u32 t32; > + > + *sd = NULL; > + > + inode_lock_shared(&ni->vfs_inode); > + > + fnd_sii = fnd_get(indx); > + if (!fnd_sii) { > + err = -ENOMEM; > + goto out; > + } > + > + root_sii = indx_get_root(indx, ni, NULL, NULL); > + if (!root_sii) { > + err = -EINVAL; > + goto out; > + } > + > + /* Try to find this SECURITY descriptor in SII indexes */ > + err = indx_find(indx, ni, root_sii, &security_id, sizeof(security_id), > + NULL, &diff, (struct NTFS_DE **)&sii_e, fnd_sii); > + if (err) > + goto out; > + > + if (diff) > + goto out; > + > + t32 = le32_to_cpu(sii_e->sec_hdr.size); > + if (t32 < SIZEOF_SECURITY_HDR) { > + err = -EINVAL; > + goto out; > + } > + > + if (t32 > SIZEOF_SECURITY_HDR + 0x10000) { > + /* > + * looks like too big security. 0x10000 - is arbitrary big number > + */ > + err = -EFBIG; > + goto out; > + } > + > + *size = t32 - SIZEOF_SECURITY_HDR; > + > + p = ntfs_alloc(*size, 0); > + if (!p) { > + err = -ENOMEM; > + goto out; > + } > + > + err = ntfs_read_run_nb(sbi, &ni->file.run, > + le64_to_cpu(sii_e->sec_hdr.off), &d_security, > + sizeof(d_security), NULL); > + if (err) > + goto out; > + > + if (memcmp(&d_security, &sii_e->sec_hdr, SIZEOF_SECURITY_HDR)) { > + err = -EINVAL; > + goto out; > + } > + > + err = ntfs_read_run_nb(sbi, &ni->file.run, > + le64_to_cpu(sii_e->sec_hdr.off) + > + SIZEOF_SECURITY_HDR, > + p, *size, NULL); > + if (err) > + goto out; > + > + *sd = p; > + p = NULL; > + > +out: > + ntfs_free(p); > + fnd_put(fnd_sii); > + inode_unlock_shared(&ni->vfs_inode); > + > + return err; > +} > + > +/* > + * ntfs_insert_security > + * > + * inserts security descriptor into $Secure::SDS > + * > + * SECURITY Descriptor Stream data is organized into chunks of 256K bytes > + * and it contains a mirror copy of each security descriptor. When writing > + * to a security descriptor at location X, another copy will be written at > + * location (X+256K). > + * When writing a security descriptor that will cross the 256K boundary, > + * the pointer will be advanced by 256K to skip > + * over the mirror portion. > + */ > +int ntfs_insert_security(struct ntfs_sb_info *sbi, const void *sd, u32 size_sd, > + __le32 *security_id, bool *inserted) > +{ > + int err, diff; > + struct ntfs_inode *ni = sbi->security.ni; > + struct ntfs_index *indx_sdh = &sbi->security.index_sdh; > + struct ntfs_index *indx_sii = &sbi->security.index_sii; > + struct NTFS_DE_SDH *e; > + struct NTFS_DE_SDH sdh_e; > + struct NTFS_DE_SII sii_e; > + struct SECURITY_HDR *d_security; > + u32 new_sec_size = size_sd + SIZEOF_SECURITY_HDR; > + u32 aligned_sec_size = Quad2Align(new_sec_size); > + struct SECURITY_KEY hash_key; > + struct ntfs_fnd *fnd_sdh = NULL; > + const struct INDEX_ROOT *root_sdh; > + const struct INDEX_ROOT *root_sii; > + u64 mirr_off, new_sds_size; > + u32 next, left; > + > + static_assert((1 << Log2OfSecurityDescriptorsBlockSize) == > + SecurityDescriptorsBlockSize); > + > + hash_key.hash = security_hash(sd, size_sd); > + hash_key.sec_id = SECURITY_ID_INVALID; > + > + if (inserted) > + *inserted = false; > + *security_id = SECURITY_ID_INVALID; > + > + /* Allocate a temporal buffer*/ > + d_security = ntfs_alloc(aligned_sec_size, 1); > + if (!d_security) > + return -ENOMEM; > + > + inode_lock(&ni->vfs_inode); > + > + fnd_sdh = fnd_get(indx_sdh); > + if (!fnd_sdh) { > + err = -ENOMEM; > + goto out; > + } > + > + root_sdh = indx_get_root(indx_sdh, ni, NULL, NULL); > + if (!root_sdh) { > + err = -EINVAL; > + goto out; > + } > + > + root_sii = indx_get_root(indx_sii, ni, NULL, NULL); > + if (!root_sii) { > + err = -EINVAL; > + goto out; > + } > + > + /* > + * Check if such security already exists > + * use "SDH" and hash -> to get the offset in "SDS" > + */ > + err = indx_find(indx_sdh, ni, root_sdh, &hash_key, sizeof(hash_key), > + &d_security->key.sec_id, &diff, (struct NTFS_DE **)&e, > + fnd_sdh); > + if (err) > + goto out; > + > + while (e) { > + if (le32_to_cpu(e->sec_hdr.size) == new_sec_size) { > + err = ntfs_read_run_nb(sbi, &ni->file.run, > + le64_to_cpu(e->sec_hdr.off), > + d_security, new_sec_size, NULL); > + if (err) > + goto out; > + > + if (le32_to_cpu(d_security->size) == new_sec_size && > + d_security->key.hash == hash_key.hash && > + !memcmp(d_security + 1, sd, size_sd)) { > + *security_id = d_security->key.sec_id; > + /*such security already exists*/ > + err = 0; > + goto out; > + } > + } > + > + err = indx_find_sort(indx_sdh, ni, root_sdh, > + (struct NTFS_DE **)&e, fnd_sdh); > + if (err) > + goto out; > + > + if (!e || e->key.hash != hash_key.hash) > + break; > + } > + > + /* Zero unused space */ > + next = sbi->security.next_off & (SecurityDescriptorsBlockSize - 1); > + left = SecurityDescriptorsBlockSize - next; > + > + /* Zero gap until SecurityDescriptorsBlockSize */ > + if (left < new_sec_size) { > + /* zero "left" bytes from sbi->security.next_off */ > + sbi->security.next_off += SecurityDescriptorsBlockSize + left; > + } > + > + /* Zero tail of previous security */ > + //used = ni->vfs_inode.i_size & (SecurityDescriptorsBlockSize - 1); > + > + /* > + * Example: > + * 0x40438 == ni->vfs_inode.i_size > + * 0x00440 == sbi->security.next_off > + * need to zero [0x438-0x440) > + * if (next > used) { > + * u32 tozero = next - used; > + * zero "tozero" bytes from sbi->security.next_off - tozero > + */ > + > + /* format new security descriptor */ > + d_security->key.hash = hash_key.hash; > + d_security->key.sec_id = cpu_to_le32(sbi->security.next_id); > + d_security->off = cpu_to_le64(sbi->security.next_off); > + d_security->size = cpu_to_le32(new_sec_size); > + memcpy(d_security + 1, sd, size_sd); > + > + /* Write main SDS bucket */ > + err = ntfs_sb_write_run(sbi, &ni->file.run, sbi->security.next_off, > + d_security, aligned_sec_size); > + > + if (err) > + goto out; > + > + mirr_off = sbi->security.next_off + SecurityDescriptorsBlockSize; > + new_sds_size = mirr_off + aligned_sec_size; > + > + if (new_sds_size > ni->vfs_inode.i_size) { > + err = attr_set_size(ni, ATTR_DATA, SDS_NAME, > + ARRAY_SIZE(SDS_NAME), &ni->file.run, > + new_sds_size, &new_sds_size, false, NULL); > + if (err) > + goto out; > + } > + > + /* Write copy SDS bucket */ > + err = ntfs_sb_write_run(sbi, &ni->file.run, mirr_off, d_security, > + aligned_sec_size); > + if (err) > + goto out; > + > + /* Fill SII entry */ > + sii_e.de.View.data_off = > + cpu_to_le16(offsetof(struct NTFS_DE_SII, sec_hdr)); > + sii_e.de.View.data_size = cpu_to_le16(SIZEOF_SECURITY_HDR); > + sii_e.de.View.Res = 0; //?? > + sii_e.de.size = cpu_to_le16(SIZEOF_SII_DIRENTRY); > + sii_e.de.key_size = cpu_to_le16(sizeof(d_security->key.sec_id)); > + sii_e.de.flags = 0; > + sii_e.de.res = 0; > + sii_e.sec_id = d_security->key.sec_id; > + memcpy(&sii_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR); > + > + err = indx_insert_entry(indx_sii, ni, &sii_e.de, NULL, NULL); > + if (err) > + goto out; > + > + /* Fill SDH entry */ > + sdh_e.de.View.data_off = > + cpu_to_le16(offsetof(struct NTFS_DE_SDH, sec_hdr)); > + sdh_e.de.View.data_size = cpu_to_le16(SIZEOF_SECURITY_HDR); > + sdh_e.de.View.Res = 0; > + sdh_e.de.size = cpu_to_le16(SIZEOF_SDH_DIRENTRY); > + sdh_e.de.key_size = cpu_to_le16(sizeof(sdh_e.key)); > + sdh_e.de.flags = 0; > + sdh_e.de.res = 0; > + sdh_e.key.hash = d_security->key.hash; > + sdh_e.key.sec_id = d_security->key.sec_id; > + memcpy(&sdh_e.sec_hdr, d_security, SIZEOF_SECURITY_HDR); > + sdh_e.magic[0] = cpu_to_le16('I'); > + sdh_e.magic[1] = cpu_to_le16('I'); > + > + fnd_clear(fnd_sdh); > + err = indx_insert_entry(indx_sdh, ni, &sdh_e.de, (void *)(size_t)1, > + fnd_sdh); > + if (err) > + goto out; > + > + *security_id = d_security->key.sec_id; > + if (inserted) > + *inserted = true; > + > + /* Update Id and offset for next descriptor */ > + sbi->security.next_id += 1; > + sbi->security.next_off += aligned_sec_size; > + > +out: > + fnd_put(fnd_sdh); > + inode_unlock(&ni->vfs_inode); > + ntfs_free(d_security); > + > + return err; > +} > + > +/* > + * ntfs_reparse_init > + * > + * loads and parse $Extend/$Reparse > + */ > +int ntfs_reparse_init(struct ntfs_sb_info *sbi) > +{ > + int err; > + struct ntfs_inode *ni = sbi->reparse.ni; > + struct ntfs_index *indx = &sbi->reparse.index_r; > + struct ATTRIB *attr; > + struct ATTR_LIST_ENTRY *le; > + const struct INDEX_ROOT *root_r; > + > + if (!ni) > + return 0; > + > + le = NULL; > + attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SR_NAME, > + ARRAY_SIZE(SR_NAME), NULL, NULL); > + if (!attr) { > + err = -EINVAL; > + goto out; > + } > + > + root_r = resident_data(attr); > + if (root_r->type != ATTR_ZERO || > + root_r->rule != NTFS_COLLATION_TYPE_UINTS) { > + err = -EINVAL; > + goto out; > + } > + > + err = indx_init(indx, sbi, attr, INDEX_MUTEX_SR); > + if (err) > + goto out; > + > +out: > + return err; > +} > + > +/* > + * ntfs_objid_init > + * > + * loads and parse $Extend/$ObjId > + */ > +int ntfs_objid_init(struct ntfs_sb_info *sbi) > +{ > + int err; > + struct ntfs_inode *ni = sbi->objid.ni; > + struct ntfs_index *indx = &sbi->objid.index_o; > + struct ATTRIB *attr; > + struct ATTR_LIST_ENTRY *le; > + const struct INDEX_ROOT *root; > + > + if (!ni) > + return 0; > + > + le = NULL; > + attr = ni_find_attr(ni, NULL, &le, ATTR_ROOT, SO_NAME, > + ARRAY_SIZE(SO_NAME), NULL, NULL); > + if (!attr) { > + err = -EINVAL; > + goto out; > + } > + > + root = resident_data(attr); > + if (root->type != ATTR_ZERO || > + root->rule != NTFS_COLLATION_TYPE_UINTS) { > + err = -EINVAL; > + goto out; > + } > + > + err = indx_init(indx, sbi, attr, INDEX_MUTEX_SO); > + if (err) > + goto out; > + > +out: > + return err; > +} > + > +int ntfs_objid_remove(struct ntfs_sb_info *sbi, struct GUID *guid) > +{ > + int err; > + struct ntfs_inode *ni = sbi->objid.ni; > + struct ntfs_index *indx = &sbi->objid.index_o; > + > + if (!ni) > + return -EINVAL; > + > + inode_lock(&ni->vfs_inode); > + > + err = indx_delete_entry(indx, ni, guid, sizeof(*guid), NULL); > + > + inode_unlock(&ni->vfs_inode); > + > + return err; > +} > + > +int ntfs_insert_reparse(struct ntfs_sb_info *sbi, __le32 rtag, > + const struct MFT_REF *ref) > +{ > + int err; > + struct ntfs_inode *ni = sbi->reparse.ni; > + struct ntfs_index *indx = &sbi->reparse.index_r; > + struct NTFS_DE_R re; > + > + if (!ni) > + return -EINVAL; > + > + memset(&re, 0, sizeof(re)); > + > + re.Key.ReparseTag = rtag; > + memcpy(&re.Key.ref, ref, sizeof(*ref)); > + > + re.de.View.data_off = cpu_to_le16(offsetof(struct NTFS_DE_R, Key)); > + re.de.size = cpu_to_le16(QuadAlign(SIZEOF_R_DIRENTRY)); > + re.de.key_size = cpu_to_le16(sizeof(re.Key)); > + > + inode_lock(&ni->vfs_inode); > + > + err = indx_insert_entry(indx, ni, &re.de, NULL, NULL); > + > + inode_unlock(&ni->vfs_inode); > + > + return err; > +} > + > +int ntfs_remove_reparse(struct ntfs_sb_info *sbi, __le32 rtag, > + const struct MFT_REF *ref) > +{ > + int err; > + struct ntfs_inode *ni = sbi->reparse.ni; > + struct ntfs_index *indx = &sbi->reparse.index_r; > + struct REPARSE_KEY rkey; > + int diff; > + struct NTFS_DE_R *re; > + struct ntfs_fnd *fnd = NULL; > + struct INDEX_ROOT *root_r; > + > + if (!ni) > + return -EINVAL; > + > + rkey.ReparseTag = rtag; > + rkey.ref = *ref; > + > + inode_lock(&ni->vfs_inode); > + > + if (rtag) { > + err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL); > + goto out1; > + } > + > + fnd = fnd_get(indx); > + if (!fnd) { > + err = -ENOMEM; > + goto out1; > + } > + > + root_r = indx_get_root(indx, ni, NULL, NULL); > + if (!root_r) { > + err = -EINVAL; > + goto out; > + } > + > + err = indx_find(indx, ni, root_r, &rkey, sizeof(rkey), NULL, &diff, > + (struct NTFS_DE **)&re, fnd); > + if (err) > + goto out; > + > + if (memcmp(&re->Key.ref, ref, sizeof(*ref))) > + goto out; > + > + memcpy(&rkey, &re->Key, sizeof(rkey)); > + > + fnd_put(fnd); > + fnd = NULL; > + > + err = indx_delete_entry(indx, ni, &rkey, sizeof(rkey), NULL); > + if (err) > + goto out; > + > +out: > + fnd_put(fnd); > + > +out1: > + inode_unlock(&ni->vfs_inode); > + > + return err; > +} > + > +static inline void ntfs_unmap_and_discard(struct ntfs_sb_info *sbi, CLST lcn, > + CLST len) > +{ > + ntfs_unmap_meta(sbi->sb, lcn, len); > + ntfs_discard(sbi, lcn, len); > +} > + > +void mark_as_free_ex(struct ntfs_sb_info *sbi, CLST lcn, CLST len, bool trim) > +{ > + CLST end, i; > + struct wnd_bitmap *wnd = &sbi->used.bitmap; > + > + down_write_nested(&wnd->rw_lock, BITMAP_MUTEX_CLUSTERS); > + if (!wnd_is_used(wnd, lcn, len)) { > + ntfs_set_state(sbi, NTFS_DIRTY_ERROR); > + > + end = lcn + len; > + len = 0; > + for (i = lcn; i < end; i++) { > + if (wnd_is_used(wnd, i, 1)) { > + if (!len) > + lcn = i; > + len += 1; > + continue; > + } > + > + if (!len) > + continue; > + > + if (trim) > + ntfs_unmap_and_discard(sbi, lcn, len); > + > + wnd_set_free(wnd, lcn, len); > + len = 0; > + } > + > + if (!len) > + goto out; > + } > + > + if (trim) > + ntfs_unmap_and_discard(sbi, lcn, len); > + wnd_set_free(wnd, lcn, len); > + > +out: > + up_write(&wnd->rw_lock); > +} > + > +/* > + * run_deallocate > + * > + * deallocate clusters > + */ > +int run_deallocate(struct ntfs_sb_info *sbi, struct runs_tree *run, bool trim) > +{ > + CLST lcn, len; > + size_t idx = 0; > + > + while (run_get_entry(run, idx++, NULL, &lcn, &len)) { > + if (lcn == SPARSE_LCN) > + continue; > + > + mark_as_free_ex(sbi, lcn, len, trim); > + } > + > + return 0; > +} > diff --git a/fs/ntfs3/index.c b/fs/ntfs3/index.c > new file mode 100644 > index 000000000000..d7633d69b714 > --- /dev/null > +++ b/fs/ntfs3/index.c > @@ -0,0 +1,2639 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * linux/fs/ntfs3/index.c > + * > + * Copyright (C) 2019-2020 Paragon Software GmbH, All rights reserved. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include "debug.h" > +#include "ntfs.h" > +#include "ntfs_fs.h" > + > +static const struct INDEX_NAMES { > + const __le16 *name; > + u8 name_len; > +} s_index_names[INDEX_MUTEX_TOTAL] = { > + { I30_NAME, ARRAY_SIZE(I30_NAME) }, { SII_NAME, ARRAY_SIZE(SII_NAME) }, > + { SDH_NAME, ARRAY_SIZE(SDH_NAME) }, { SO_NAME, ARRAY_SIZE(SO_NAME) }, > + { SQ_NAME, ARRAY_SIZE(SQ_NAME) }, { SR_NAME, ARRAY_SIZE(SR_NAME) }, > +}; > + > +static int cmp_fnames(const struct ATTR_FILE_NAME *f1, size_t l1, > + const struct ATTR_FILE_NAME *f2, size_t l2, > + const struct ntfs_sb_info *sbi) > +{ > + int diff; > + u16 fsize2; > + > + if (l2 <= offsetof(struct ATTR_FILE_NAME, name)) > + return -1; > + > + fsize2 = fname_full_size(f2); > + if (l2 < fsize2) > + return -1; > + > + if (!l1) { > + const struct cpu_str *s1 = (struct cpu_str *)f1; > + const struct le_str *s2 = (struct le_str *)&f2->name_len; > + > + diff = ntfs_cmp_names_cpu(s1, s2, sbi->upcase); > + > + if (diff) > + return diff; > + > + /* > + * If names are equal (case insensitive) > + * try to compare it case sensitive > + */ > + if (/*sbi->options.nocase || */ f2->type == FILE_NAME_DOS) > + return 0; > + > + return ntfs_cmp_names_cpu(s1, s2, NULL); > + } > + > + diff = ntfs_cmp_names(f1->name, f1->name_len, f2->name, f2->name_len, > + sbi->upcase); > + > + if (diff) > + return diff; > + > + /* > + * If names are equal (case insensitive) > + * try to compare it case sensitive > + */ > + if (/*sbi->options.nocase || */ f2->type == FILE_NAME_DOS) > + return 0; > + > + return ntfs_cmp_names(f1->name, f1->name_len, f2->name, f2->name_len, > + NULL); > +} > + > +static int cmp_uint(const u32 *k1, size_t l1, const u32 *k2, size_t l2, > + const void *p) > +{ > + if (l2 < sizeof(u32)) > + return -1; > + > + if (*k1 < *k2) > + return -1; > + if (*k1 > *k2) > + return 1; > + return 0; > +} > + > +static int cmp_sdh(const struct SECURITY_KEY *k1, size_t l1, > + const struct SECURITY_KEY *k2, size_t l2, const void *p) > +{ > + u32 t1, t2; > + > + if (l2 < sizeof(struct SECURITY_KEY)) > + return -1; > + > + t1 = le32_to_cpu(k1->hash); > + t2 = le32_to_cpu(k2->hash); > + > + /* First value is a hash value itself */ > + if (t1 < t2) > + return -1; > + if (t1 > t2) > + return 1; > + > + /* Second value is security Id */ > + if (p) { > + t1 = le32_to_cpu(k1->sec_id); > + t2 = le32_to_cpu(k2->sec_id); > + if (t1 < t2) > + return -1; > + if (t1 > t2) > + return 1; > + } > + > + return 0; > +} > + > +static int cmp_uints(const __le32 *k1, size_t l1, const __le32 *k2, size_t l2, > + const void *p) > +{ > + size_t count; > + > + if (l2 < sizeof(int)) > + return -1; > + > + for (count = min(l1, l2) >> 2; count > 0; --count, ++k1, ++k2) { > + u32 t1 = le32_to_cpu(*k1); > + u32 t2 = le32_to_cpu(*k2); > + > + if (t1 > t2) > + return 1; > + if (t1 < t2) > + return -1; > + } > + > + if (l1 > l2) > + return 1; > + if (l1 < l2) > + return -1; > + > + return 0; > +} > + > +static inline NTFS_CMP_FUNC get_cmp_func(const struct INDEX_ROOT *root) > +{ > + switch (root->type) { > + case ATTR_NAME: > + if (root->rule == NTFS_COLLATION_TYPE_FILENAME) > + return (NTFS_CMP_FUNC)&cmp_fnames; > + break; > + case ATTR_ZERO: > + switch (root->rule) { > + case NTFS_COLLATION_TYPE_UINT: > + return (NTFS_CMP_FUNC)&cmp_uint; > + case NTFS_COLLATION_TYPE_SECURITY_HASH: > + return (NTFS_CMP_FUNC)&cmp_sdh; > + case NTFS_COLLATION_TYPE_UINTS: > + return (NTFS_CMP_FUNC)&cmp_uints; > + default: > + break; > + } > + default: > + break; > + } > + > + return NULL; > +} > + > +struct bmp_buf { > + struct ATTRIB *b; > + struct mft_inode *mi; > + struct buffer_head *bh; > + ulong *buf; > + size_t bit; > + u32 nbits; > + u64 new_valid; > +}; > + > +static int bmp_buf_get(struct ntfs_index *indx, struct ntfs_inode *ni, > + size_t bit, struct bmp_buf *bbuf) > +{ > + struct ATTRIB *b; > + size_t data_size, valid_size, vbo, off = bit >> 3; > + struct ntfs_sb_info *sbi = ni->mi.sbi; > + CLST vcn = off >> sbi->cluster_bits; > + struct ATTR_LIST_ENTRY *le = NULL; > + struct buffer_head *bh; > + struct super_block *sb; > + u32 blocksize; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + > + bbuf->bh = NULL; > + > + b = ni_find_attr(ni, NULL, &le, ATTR_BITMAP, in->name, in->name_len, > + &vcn, &bbuf->mi); > + bbuf->b = b; > + if (!b) > + return -EINVAL; > + > + if (!b->non_res) { > + data_size = le32_to_cpu(b->res.data_size); > + > + if (off >= data_size) > + return -EINVAL; > + > + bbuf->buf = (ulong *)resident_data(b); > + bbuf->bit = 0; > + bbuf->nbits = data_size * 8; > + > + return 0; > + } > + > + data_size = le64_to_cpu(b->nres.data_size); > + if (off >= data_size) { > + WARN_ON(1); > + return -EINVAL; > + } > + > + valid_size = le64_to_cpu(b->nres.valid_size); > + > + bh = ntfs_bread_run(sbi, &indx->bitmap_run, off); > + if (!bh) > + return -EIO; > + > + if (IS_ERR(bh)) > + return PTR_ERR(bh); > + > + bbuf->bh = bh; > + > + if (buffer_locked(bh)) > + __wait_on_buffer(bh); > + > + lock_buffer(bh); > + > + sb = sbi->sb; > + blocksize = sb->s_blocksize; > + > + vbo = off & ~(size_t)sbi->block_mask; > + > + bbuf->new_valid = vbo + blocksize; > + if (bbuf->new_valid <= valid_size) > + bbuf->new_valid = 0; > + else if (bbuf->new_valid > data_size) > + bbuf->new_valid = data_size; > + > + if (vbo >= valid_size) { > + memset(bh->b_data, 0, blocksize); > + } else if (vbo + blocksize > valid_size) { > + u32 voff = valid_size & sbi->block_mask; > + > + memset(bh->b_data + voff, 0, blocksize - voff); > + } > + > + bbuf->buf = (ulong *)bh->b_data; > + bbuf->bit = 8 * (off & ~(size_t)sbi->block_mask); > + bbuf->nbits = 8 * blocksize; > + > + return 0; > +} > + > +static void bmp_buf_put(struct bmp_buf *bbuf, bool dirty) > +{ > + struct buffer_head *bh = bbuf->bh; > + struct ATTRIB *b = bbuf->b; > + > + if (!bh) { > + if (b && !b->non_res && dirty) > + bbuf->mi->dirty = true; > + return; > + } > + > + if (!dirty) > + goto out; > + > + if (bbuf->new_valid) { > + b->nres.valid_size = cpu_to_le64(bbuf->new_valid); > + bbuf->mi->dirty = true; > + } > + > + set_buffer_uptodate(bh); > + mark_buffer_dirty(bh); > + > +out: > + unlock_buffer(bh); > + put_bh(bh); > +} > + > +/* > + * indx_mark_used > + * > + * marks the bit 'bit' as used > + */ > +static int indx_mark_used(struct ntfs_index *indx, struct ntfs_inode *ni, > + size_t bit) > +{ > + int err; > + struct bmp_buf bbuf; > + > + err = bmp_buf_get(indx, ni, bit, &bbuf); > + if (err) > + return err; > + > + __set_bit(bit - bbuf.bit, bbuf.buf); > + > + bmp_buf_put(&bbuf, true); > + > + return 0; > +} > + > +/* > + * indx_mark_free > + * > + * the bit 'bit' as free > + */ > +static int indx_mark_free(struct ntfs_index *indx, struct ntfs_inode *ni, > + size_t bit) > +{ > + int err; > + struct bmp_buf bbuf; > + > + err = bmp_buf_get(indx, ni, bit, &bbuf); > + if (err) > + return err; > + > + __clear_bit(bit - bbuf.bit, bbuf.buf); > + > + bmp_buf_put(&bbuf, true); > + > + return 0; > +} > + > +static int scan_nres_bitmap(struct ntfs_sb_info *sbi, struct ATTRIB *bitmap, > + struct runs_tree *run, size_t from, > + bool (*fn)(const ulong *buf, u32 bit, u32 bits, > + size_t *ret), > + size_t *ret) > +{ > + struct super_block *sb = sbi->sb; > + u32 nbits = sb->s_blocksize * 8; > + u32 blocksize = sb->s_blocksize; > + u64 valid_size = le64_to_cpu(bitmap->nres.valid_size); > + u64 data_size = le64_to_cpu(bitmap->nres.data_size); > + sector_t eblock = bytes_to_block(sb, data_size); > + size_t vbo = from >> 3; > + sector_t blk = (vbo & sbi->cluster_mask) >> sb->s_blocksize_bits; > + sector_t vblock = vbo >> sb->s_blocksize_bits; > + sector_t blen, block; > + CLST lcn, len; > + size_t idx; > + struct buffer_head *bh; > + > + *ret = MINUS_ONE_T; > + > + if (vblock >= eblock) > + return 0; > + > + from &= nbits - 1; > + > + if (!run_lookup_entry(run, vbo >> sbi->cluster_bits, &lcn, &len, > + &idx)) { > + return -ENOENT; > + } > + > + blen = (sector_t)len * sbi->blocks_per_cluster; > + block = (sector_t)lcn * sbi->blocks_per_cluster; > + > +next_run: > + for (; blk < blen; blk++, from = 0) { > + bool ok; > + > + bh = ntfs_bread(sb, block + blk); > + if (!bh) > + return -EIO; > + > + vbo = (u64)vblock << sb->s_blocksize_bits; > + if (vbo >= valid_size) { > + memset(bh->b_data, 0, blocksize); > + } else if (vbo + blocksize > valid_size) { > + u32 voff = valid_size & sbi->block_mask; > + > + memset(bh->b_data + voff, 0, blocksize - voff); > + } > + > + if (vbo + blocksize > data_size) > + nbits = 8 * (data_size - vbo); > + > + ok = nbits > from ? > + (*fn)((ulong *)bh->b_data, from, nbits, ret) : > + false; > + put_bh(bh); > + > + if (ok) { > + *ret += 8 * vbo; > + return 0; > + } > + > + if (++vblock >= eblock) { > + *ret = MINUS_ONE_T; > + return 0; > + } > + } > + > + if (!run_get_entry(run, ++idx, NULL, &lcn, &len)) > + return -ENOENT; > + > + blk = 0; > + blen = (sector_t)len * sbi->blocks_per_cluster; > + block = (sector_t)lcn * sbi->blocks_per_cluster; > + goto next_run; > +} > + > +static bool scan_for_free(const ulong *buf, u32 bit, u32 bits, size_t *ret) > +{ > + size_t pos = find_next_zero_bit(buf, bits, bit); > + > + if (pos >= bits) > + return false; > + *ret = pos; > + return true; > +} > + > +/* > + * indx_find_free > + * > + * looks for free bit > + * returns -1 if no free bits > + */ > +static int indx_find_free(struct ntfs_index *indx, struct ntfs_inode *ni, > + size_t *bit, struct ATTRIB **bitmap) > +{ > + struct ATTRIB *b; > + struct ATTR_LIST_ENTRY *le = NULL; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + > + b = ni_find_attr(ni, NULL, &le, ATTR_BITMAP, in->name, in->name_len, > + NULL, NULL); > + > + if (!b) > + return -ENOENT; > + > + *bitmap = b; > + *bit = MINUS_ONE_T; > + > + if (!b->non_res) { > + u32 nbits = 8 * le32_to_cpu(b->res.data_size); > + size_t pos = find_next_zero_bit(resident_data(b), nbits, 0); > + > + if (pos < nbits) > + *bit = pos; > + } else { > + int err = scan_nres_bitmap(ni->mi.sbi, b, &indx->bitmap_run, 0, > + &scan_for_free, bit); > + > + if (err) > + return err; > + } > + > + return 0; > +} > + > +static bool scan_for_used(const ulong *buf, u32 bit, u32 bits, size_t *ret) > +{ > + size_t pos = find_next_bit(buf, bits, bit); > + > + if (pos >= bits) > + return false; > + *ret = pos; > + return true; > +} > + > +/* > + * indx_used_bit > + * > + * looks for used bit > + * returns MINUS_ONE_T if no used bits > + */ > +int indx_used_bit(struct ntfs_index *indx, struct ntfs_inode *ni, size_t *bit) > +{ > + struct ATTRIB *b; > + struct ATTR_LIST_ENTRY *le = NULL; > + size_t from = *bit; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + > + b = ni_find_attr(ni, NULL, &le, ATTR_BITMAP, in->name, in->name_len, > + NULL, NULL); > + > + if (!b) > + return -ENOENT; > + > + *bit = MINUS_ONE_T; > + > + if (!b->non_res) { > + u32 nbits = le32_to_cpu(b->res.data_size) * 8; > + size_t pos = find_next_bit(resident_data(b), nbits, from); > + > + if (pos < nbits) > + *bit = pos; > + } else { > + int err = scan_nres_bitmap(ni->mi.sbi, b, &indx->bitmap_run, > + from, &scan_for_used, bit); > + if (err) > + return err; > + } > + > + return 0; > +} > + > +/* > + * hdr_find_split > + * > + * finds a point at which the index allocation buffer would like to > + * be split. > + * NOTE: This function should never return 'END' entry NULL returns on error > + */ > +static inline const struct NTFS_DE *hdr_find_split(const struct INDEX_HDR *hdr) > +{ > + size_t o; > + const struct NTFS_DE *e = hdr_first_de(hdr); > + u32 used_2 = le32_to_cpu(hdr->used) >> 1; > + u16 esize = le16_to_cpu(e->size); > + > + if (!e || de_is_last(e)) > + return NULL; > + > + for (o = le32_to_cpu(hdr->de_off) + esize; o < used_2; o += esize) { > + const struct NTFS_DE *p = e; > + > + e = Add2Ptr(hdr, o); > + > + /* We must not return END entry */ > + if (de_is_last(e)) > + return p; > + > + esize = le16_to_cpu(e->size); > + } > + > + return e; > +} > + > +/* > + * hdr_insert_head > + * > + * inserts some entries at the beginning of the buffer. > + * It is used to insert entries into a newly-created buffer. > + */ > +static inline const struct NTFS_DE * > +hdr_insert_head(struct INDEX_HDR *hdr, const void *ins, u32 ins_bytes) > +{ > + u32 to_move; > + struct NTFS_DE *e = hdr_first_de(hdr); > + u32 used = le32_to_cpu(hdr->used); > + > + if (!e) > + return NULL; > + > + /* Now we just make room for the inserted entries and jam it in. */ > + to_move = used - le32_to_cpu(hdr->de_off); > + memmove(Add2Ptr(e, ins_bytes), e, to_move); > + memcpy(e, ins, ins_bytes); > + hdr->used = cpu_to_le32(used + ins_bytes); > + > + return e; > +} > + > +void fnd_clear(struct ntfs_fnd *fnd) > +{ > + int i; > + > + for (i = 0; i < fnd->level; i++) { > + struct indx_node *n = fnd->nodes[i]; > + > + if (!n) > + continue; > + > + put_indx_node(n); > + fnd->nodes[i] = NULL; > + } > + fnd->level = 0; > + fnd->root_de = NULL; > +} > + > +static int fnd_push(struct ntfs_fnd *fnd, struct indx_node *n, > + struct NTFS_DE *e) > +{ > + int i; > + > + i = fnd->level; > + if (i < 0 || i >= ARRAY_SIZE(fnd->nodes)) > + return -EINVAL; > + fnd->nodes[i] = n; > + fnd->de[i] = e; > + fnd->level += 1; > + return 0; > +} > + > +static struct indx_node *fnd_pop(struct ntfs_fnd *fnd) > +{ > + struct indx_node *n; > + int i = fnd->level; > + > + i -= 1; > + n = fnd->nodes[i]; > + fnd->nodes[i] = NULL; > + fnd->level = i; > + > + return n; > +} > + > +static bool fnd_is_empty(struct ntfs_fnd *fnd) > +{ > + if (!fnd->level) > + return !fnd->root_de; > + > + return !fnd->de[fnd->level - 1]; > +} > + > +struct ntfs_fnd *fnd_get(struct ntfs_index *indx) > +{ > + struct ntfs_fnd *fnd = ntfs_alloc(sizeof(struct ntfs_fnd), 1); > + > + if (!fnd) > + return NULL; > + > + return fnd; > +} > + > +void fnd_put(struct ntfs_fnd *fnd) > +{ > + if (!fnd) > + return; > + fnd_clear(fnd); > + ntfs_free(fnd); > +} > + > +/* > + * hdr_find_e > + * > + * locates an entry the index buffer. > + * If no matching entry is found, it returns the first entry which is greater > + * than the desired entry If the search key is greater than all the entries the > + * buffer, it returns the 'end' entry. This function does a binary search of the > + * current index buffer, for the first entry that is <= to the search value > + * Returns NULL if error > + */ > +static struct NTFS_DE *hdr_find_e(const struct ntfs_index *indx, > + const struct INDEX_HDR *hdr, const void *key, > + size_t key_len, const void *ctx, int *diff) > +{ > + struct NTFS_DE *e; > + NTFS_CMP_FUNC cmp = indx->cmp; > + u32 e_size, e_key_len; > + u32 end = le32_to_cpu(hdr->used); > + u32 off = le32_to_cpu(hdr->de_off); > + > +#ifdef NTFS3_INDEX_BINARY_SEARCH > + int max_idx = 0, fnd, min_idx; > + int nslots = 64; > + u16 *offs; > + > + if (end > 0x10000) > + goto next; > + > + offs = ntfs_alloc(sizeof(u16) * nslots, 0); > + if (!offs) > + goto next; > + > + /* use binary search algorithm */ > +next1: > + if (off + sizeof(struct NTFS_DE) > end) { > + e = NULL; > + goto out1; > + } > + e = Add2Ptr(hdr, off); > + e_size = le16_to_cpu(e->size); > + > + if (e_size < sizeof(struct NTFS_DE) || off + e_size > end) { > + e = NULL; > + goto out1; > + } > + > + if (max_idx >= nslots) { > + u16 *ptr; > + int new_slots = QuadAlign(2 * nslots); > + > + ptr = ntfs_alloc(sizeof(u16) * new_slots, 0); > + if (ptr) > + memcpy(ptr, offs, sizeof(u16) * max_idx); > + ntfs_free(offs); > + offs = ptr; > + nslots = new_slots; > + if (!ptr) > + goto next; > + } > + > + /* Store entry table */ > + offs[max_idx] = off; > + > + if (!de_is_last(e)) { > + off += e_size; > + max_idx += 1; > + goto next1; > + } > + > + /* > + * Table of pointers is created > + * Use binary search to find entry that is <= to the search value > + */ > + fnd = -1; > + min_idx = 0; > + > + while (min_idx <= max_idx) { > + int mid_idx = min_idx + ((max_idx - min_idx) >> 1); > + int diff2; > + > + e = Add2Ptr(hdr, offs[mid_idx]); > + > + e_key_len = le16_to_cpu(e->key_size); > + > + diff2 = (*cmp)(key, key_len, e + 1, e_key_len, ctx); > + > + if (!diff2) { > + *diff = 0; > + goto out1; > + } > + > + if (diff2 < 0) { > + max_idx = mid_idx - 1; > + fnd = mid_idx; > + if (!fnd) > + break; > + } else { > + min_idx = mid_idx + 1; > + } > + } > + > + if (fnd == -1) { > + e = NULL; > + goto out1; > + } > + > + *diff = -1; > + e = Add2Ptr(hdr, offs[fnd]); > + > +out1: > + ntfs_free(offs); > + > + return e; > +#endif > + > +next: > + /* > + * Entries index are sorted > + * Enumerate all entries until we find entry that is <= to the search value > + */ > + if (off + sizeof(struct NTFS_DE) > end) > + return NULL; > + > + e = Add2Ptr(hdr, off); > + e_size = le16_to_cpu(e->size); > + > + if (e_size < sizeof(struct NTFS_DE) || off + e_size > end) > + return NULL; > + > + off += e_size; > + > + e_key_len = le16_to_cpu(e->key_size); > + > + *diff = (*cmp)(key, key_len, e + 1, e_key_len, ctx); > + if (!*diff) > + return e; > + > + if (*diff <= 0) > + return e; > + > + if (de_is_last(e)) { > + *diff = 1; > + return e; > + } > + goto next; > +} > + > +/* > + * hdr_insert_de > + * > + * inserts an index entry into the buffer. > + * 'before' should be a pointer previously returned from hdr_find_e > + */ > +static struct NTFS_DE *hdr_insert_de(const struct ntfs_index *indx, > + struct INDEX_HDR *hdr, > + const struct NTFS_DE *de, > + struct NTFS_DE *before, const void *ctx) > +{ > + int diff; > + size_t off = PtrOffset(hdr, before); > + u32 used = le32_to_cpu(hdr->used); > + u32 total = le32_to_cpu(hdr->total); > + u16 de_size = le16_to_cpu(de->size); > + > + /* First, check to see if there's enough room */ > + if (used + de_size > total) > + return NULL; > + > + /* We know there's enough space, so we know we'll succeed. */ > + if (before) { > + /* Check that before is inside Index */ > + if (off >= used || off < le32_to_cpu(hdr->de_off) || > + off + le16_to_cpu(before->size) > total) { > + return NULL; > + } > + goto ok; > + } > + /* No insert point is applied. Get it manually */ > + before = hdr_find_e(indx, hdr, de + 1, le16_to_cpu(de->key_size), ctx, > + &diff); > + if (!before) > + return NULL; > + off = PtrOffset(hdr, before); > + > +ok: > + /* Now we just make room for the entry and jam it in. */ > + memmove(Add2Ptr(before, de_size), before, used - off); > + > + hdr->used = cpu_to_le32(used + de_size); > + memcpy(before, de, de_size); > + > + return before; > +} > + > +/* > + * hdr_delete_de > + * > + * removes an entry from the index buffer > + */ > +static inline struct NTFS_DE *hdr_delete_de(struct INDEX_HDR *hdr, > + struct NTFS_DE *re) > +{ > + u32 used = le32_to_cpu(hdr->used); > + u16 esize = le16_to_cpu(re->size); > + u32 off = PtrOffset(hdr, re); > + int bytes = used - (off + esize); > + > + if (off >= used || esize < sizeof(struct NTFS_DE) || > + bytes < sizeof(struct NTFS_DE)) > + return NULL; > + > + hdr->used = cpu_to_le32(used - esize); > + memmove(re, Add2Ptr(re, esize), bytes); > + > + return re; > +} > + > +void indx_clear(struct ntfs_index *indx) > +{ > + run_close(&indx->alloc_run); > + run_close(&indx->bitmap_run); > +} > + > +int indx_init(struct ntfs_index *indx, struct ntfs_sb_info *sbi, > + const struct ATTRIB *attr, enum index_mutex_classed type) > +{ > + u32 t32; > + const struct INDEX_ROOT *root = resident_data(attr); > + > + /* Check root fields */ > + if (!root->index_block_clst) > + return -EINVAL; > + > + indx->type = type; > + indx->idx2vbn_bits = __ffs(root->index_block_clst); > + > + t32 = le32_to_cpu(root->index_block_size); > + indx->index_bits = blksize_bits(t32); > + > + /* Check index record size */ > + if (t32 < sbi->cluster_size) { > + /* index record is smaller than a cluster, use 512 blocks */ > + if (t32 != root->index_block_clst * SECTOR_SIZE) > + return -EINVAL; > + > + /* Check alignment to a cluster */ > + if ((sbi->cluster_size >> SECTOR_SHIFT) & > + (root->index_block_clst - 1)) { > + return -EINVAL; > + } > + > + indx->vbn2vbo_bits = SECTOR_SHIFT; > + } else { > + /* index record must be a multiple of cluster size */ > + if (t32 != root->index_block_clst << sbi->cluster_bits) > + return -EINVAL; > + > + indx->vbn2vbo_bits = sbi->cluster_bits; > + } > + > + indx->cmp = get_cmp_func(root); > + > + return indx->cmp ? 0 : -EINVAL; > +} > + > +static struct indx_node *indx_new(struct ntfs_index *indx, > + struct ntfs_inode *ni, CLST vbn, > + const __le64 *sub_vbn) > +{ > + int err; > + struct NTFS_DE *e; > + struct indx_node *r; > + struct INDEX_HDR *hdr; > + struct INDEX_BUFFER *index; > + u64 vbo = (u64)vbn << indx->vbn2vbo_bits; > + u32 bytes = 1u << indx->index_bits; > + u16 fn; > + u32 eo; > + > + r = ntfs_alloc(sizeof(struct indx_node), 1); > + if (!r) > + return ERR_PTR(-ENOMEM); > + > + index = ntfs_alloc(bytes, 1); > + if (!index) { > + ntfs_free(r); > + return ERR_PTR(-ENOMEM); > + } > + > + err = ntfs_get_bh(ni->mi.sbi, &indx->alloc_run, vbo, bytes, &r->nb); > + > + if (err) { > + ntfs_free(index); > + ntfs_free(r); > + return ERR_PTR(err); > + } > + > + /* Create header */ > + index->rhdr.sign = NTFS_INDX_SIGNATURE; > + index->rhdr.fix_off = cpu_to_le16(sizeof(struct INDEX_BUFFER)); // 0x28 > + fn = (bytes >> SECTOR_SHIFT) + 1; // 9 > + index->rhdr.fix_num = cpu_to_le16(fn); > + index->vbn = cpu_to_le64(vbn); > + hdr = &index->ihdr; > + eo = QuadAlign(sizeof(struct INDEX_BUFFER) + fn * sizeof(short)); > + hdr->de_off = cpu_to_le32(eo); > + > + e = Add2Ptr(hdr, eo); > + > + if (sub_vbn) { > + e->flags = NTFS_IE_LAST | NTFS_IE_HAS_SUBNODES; > + e->size = cpu_to_le16(sizeof(struct NTFS_DE) + sizeof(u64)); > + hdr->used = > + cpu_to_le32(eo + sizeof(struct NTFS_DE) + sizeof(u64)); > + de_set_vbn_le(e, *sub_vbn); > + hdr->flags = 1; > + } else { > + e->size = cpu_to_le16(sizeof(struct NTFS_DE)); > + hdr->used = cpu_to_le32(eo + sizeof(struct NTFS_DE)); > + e->flags = NTFS_IE_LAST; > + } > + > + hdr->total = cpu_to_le32(bytes - offsetof(struct INDEX_BUFFER, ihdr)); > + > + r->index = index; > + return r; > +} > + > +struct INDEX_ROOT *indx_get_root(struct ntfs_index *indx, struct ntfs_inode *ni, > + struct ATTRIB **attr, struct mft_inode **mi) > +{ > + struct ATTR_LIST_ENTRY *le = NULL; > + struct ATTRIB *a; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + > + a = ni_find_attr(ni, NULL, &le, ATTR_ROOT, in->name, in->name_len, NULL, > + mi); > + if (!a) > + return NULL; > + > + if (attr) > + *attr = a; > + > + return resident_data_ex(a, sizeof(struct INDEX_ROOT)); > +} > + > +static int indx_write(struct ntfs_index *indx, struct ntfs_inode *ni, > + struct indx_node *node, int sync) > +{ > + struct INDEX_BUFFER *ib = node->index; > + > + return ntfs_write_bh(ni->mi.sbi, &ib->rhdr, &node->nb, sync); > +} > + > +int indx_read(struct ntfs_index *indx, struct ntfs_inode *ni, CLST vbn, > + struct indx_node **node) > +{ > + int err; > + struct INDEX_BUFFER *ib; > + u64 vbo = (u64)vbn << indx->vbn2vbo_bits; > + u32 bytes = 1u << indx->index_bits; > + struct indx_node *in = *node; > + const struct INDEX_NAMES *name; > + > + if (!in) { > + in = ntfs_alloc(sizeof(struct indx_node), 1); > + if (!in) > + return -ENOMEM; > + } else { > + nb_put(&in->nb); > + } > + > + ib = in->index; > + if (!ib) { > + ib = ntfs_alloc(bytes, 0); > + if (!ib) { > + err = -ENOMEM; > + goto out; > + } > + } > + > + err = ntfs_read_bh(ni->mi.sbi, &indx->alloc_run, vbo, &ib->rhdr, bytes, > + &in->nb); > + > + if (!err) > + goto ok; > + > + if (err == 1) > + goto ok; > + > + if (err != -ENOENT) > + goto out; > + > + name = &s_index_names[indx->type]; > + err = attr_load_runs_vcn(ni, ATTR_ALLOC, name->name, name->name_len, > + &indx->alloc_run, > + vbo >> ni->mi.sbi->cluster_bits); > + if (err) > + goto out; > + > + err = ntfs_read_bh(ni->mi.sbi, &indx->alloc_run, vbo, &ib->rhdr, bytes, > + &in->nb); > + if (err == 1) > + goto ok; > + > + if (err) > + goto out; > + > +ok: > + if (err == 1) { > + ntfs_write_bh(ni->mi.sbi, &ib->rhdr, &in->nb, 0); > + err = 0; > + } > + > + in->index = ib; > + *node = in; > + > +out: > + if (ib != in->index) > + ntfs_free(ib); > + > + if (*node != in) { > + nb_put(&in->nb); > + ntfs_free(in); > + } > + > + return err; > +} > + > +/* > + * indx_find > + * > + * scans NTFS directory for given entry > + */ > +int indx_find(struct ntfs_index *indx, struct ntfs_inode *ni, > + const struct INDEX_ROOT *root, const void *key, size_t key_len, > + const void *ctx, int *diff, struct NTFS_DE **entry, > + struct ntfs_fnd *fnd) > +{ > + int err; > + struct NTFS_DE *e; > + const struct INDEX_HDR *hdr; > + struct indx_node *node; > + > + if (!root) > + root = indx_get_root(&ni->dir, ni, NULL, NULL); > + > + if (!root) { > + err = -EINVAL; > + goto out; > + } > + > + hdr = &root->ihdr; > + > + /* Check cache */ > + e = fnd->level ? fnd->de[fnd->level - 1] : fnd->root_de; > + if (e && !de_is_last(e) && > + !(*indx->cmp)(key, key_len, e + 1, le16_to_cpu(e->key_size), ctx)) { > + *entry = e; > + *diff = 0; > + return 0; > + } > + > + /* Soft finder reset */ > + fnd_clear(fnd); > + > + /* Lookup entry that is <= to the search value */ > + e = hdr_find_e(indx, hdr, key, key_len, ctx, diff); > + if (!e) > + return -EINVAL; > + > + if (fnd) > + fnd->root_de = e; > + > + err = 0; > + > + for (;;) { > + node = NULL; > + if (*diff >= 0 || !de_has_vcn_ex(e)) { > + *entry = e; > + goto out; > + } > + > + /* Read next level. */ > + err = indx_read(indx, ni, de_get_vbn(e), &node); > + if (err) > + goto out; > + > + /* Lookup entry that is <= to the search value */ > + e = hdr_find_e(indx, &node->index->ihdr, key, key_len, ctx, > + diff); > + if (!e) { > + err = -EINVAL; > + put_indx_node(node); > + goto out; > + } > + > + fnd_push(fnd, node, e); > + } > + > +out: > + return err; > +} > + > +int indx_find_sort(struct ntfs_index *indx, struct ntfs_inode *ni, > + const struct INDEX_ROOT *root, struct NTFS_DE **entry, > + struct ntfs_fnd *fnd) > +{ > + int err; > + struct indx_node *n = NULL; > + struct NTFS_DE *e; > + size_t iter = 0; > + int level = fnd->level; > + > + if (!*entry) { > + /* Start find */ > + e = hdr_first_de(&root->ihdr); > + if (!e) > + return 0; > + fnd_clear(fnd); > + fnd->root_de = e; > + } else if (!level) { > + if (de_is_last(fnd->root_de)) { > + *entry = NULL; > + return 0; > + } > + > + e = hdr_next_de(&root->ihdr, fnd->root_de); > + if (!e) > + return -EINVAL; > + fnd->root_de = e; > + } else { > + n = fnd->nodes[level - 1]; > + e = fnd->de[level - 1]; > + > + if (de_is_last(e)) > + goto pop_level; > + > + e = hdr_next_de(&n->index->ihdr, e); > + if (!e) > + return -EINVAL; > + > + fnd->de[level - 1] = e; > + } > + > + /* Just to avoid tree cycle */ > +next_iter: > + if (iter++ >= 1000) > + return -EINVAL; > + > + while (de_has_vcn_ex(e)) { > + if (le16_to_cpu(e->size) < > + sizeof(struct NTFS_DE) + sizeof(u64)) { > + if (n) { > + fnd_pop(fnd); > + ntfs_free(n); > + } > + return -EINVAL; > + } > + > + /* Read next level */ > + err = indx_read(indx, ni, de_get_vbn(e), &n); > + if (err) > + return err; > + > + /* Try next level */ > + e = hdr_first_de(&n->index->ihdr); > + if (!e) { > + ntfs_free(n); > + return -EINVAL; > + } > + > + fnd_push(fnd, n, e); > + } > + > + if (le16_to_cpu(e->size) > sizeof(struct NTFS_DE)) { > + *entry = e; > + return 0; > + } > + > +pop_level: > + for (;;) { > + if (!de_is_last(e)) > + goto next_iter; > + > + /* Pop one level */ > + if (n) { > + fnd_pop(fnd); > + ntfs_free(n); > + } > + > + level = fnd->level; > + > + if (level) { > + n = fnd->nodes[level - 1]; > + e = fnd->de[level - 1]; > + } else if (fnd->root_de) { > + n = NULL; > + e = fnd->root_de; > + fnd->root_de = NULL; > + } else { > + *entry = NULL; > + return 0; > + } > + > + if (le16_to_cpu(e->size) > sizeof(struct NTFS_DE)) { > + *entry = e; > + if (!fnd->root_de) > + fnd->root_de = e; > + return 0; > + } > + } > +} > + > +int indx_find_raw(struct ntfs_index *indx, struct ntfs_inode *ni, > + const struct INDEX_ROOT *root, struct NTFS_DE **entry, > + size_t *off, struct ntfs_fnd *fnd) > +{ > + int err; > + struct indx_node *n = NULL; > + struct NTFS_DE *e = NULL; > + struct NTFS_DE *e2; > + size_t bit; > + CLST next_used_vbn; > + CLST next_vbn; > + u32 record_size = ni->mi.sbi->record_size; > + > + /* Use non sorted algorithm */ > + if (!*entry) { > + /* This is the first call */ > + e = hdr_first_de(&root->ihdr); > + if (!e) > + return 0; > + fnd_clear(fnd); > + fnd->root_de = e; > + > + /* The first call with setup of initial element */ > + if (*off >= record_size) { > + next_vbn = (((*off - record_size) >> indx->index_bits)) > + << indx->idx2vbn_bits; > + /* jump inside cycle 'for'*/ > + goto next; > + } > + > + /* Start enumeration from root */ > + *off = 0; > + } else if (!fnd->root_de) > + return -EINVAL; > + > + for (;;) { > + /* Check if current entry can be used */ > + if (e && le16_to_cpu(e->size) > sizeof(struct NTFS_DE)) > + goto ok; > + > + if (!fnd->level) { > + /* Continue to enumerate root */ > + if (!de_is_last(fnd->root_de)) { > + e = hdr_next_de(&root->ihdr, fnd->root_de); > + if (!e) > + return -EINVAL; > + fnd->root_de = e; > + continue; > + } > + > + /* Start to enumerate indexes from 0 */ > + next_vbn = 0; > + } else { > + /* Continue to enumerate indexes */ > + e2 = fnd->de[fnd->level - 1]; > + > + n = fnd->nodes[fnd->level - 1]; > + > + if (!de_is_last(e2)) { > + e = hdr_next_de(&n->index->ihdr, e2); > + if (!e) > + return -EINVAL; > + fnd->de[fnd->level - 1] = e; > + continue; > + } > + > + /* Continue with next index */ > + next_vbn = le64_to_cpu(n->index->vbn) + > + root->index_block_clst; > + } > + > +next: > + /* Release current index */ > + if (n) { > + fnd_pop(fnd); > + put_indx_node(n); > + n = NULL; > + } > + > + /* Skip all free indexes */ > + bit = next_vbn >> indx->idx2vbn_bits; > + err = indx_used_bit(indx, ni, &bit); > + if (err == -ENOENT || bit == MINUS_ONE_T) { > + /* No used indexes */ > + *entry = NULL; > + return 0; > + } > + > + next_used_vbn = bit << indx->idx2vbn_bits; > + > + /* Read buffer into memory */ > + err = indx_read(indx, ni, next_used_vbn, &n); > + if (err) > + return err; > + > + e = hdr_first_de(&n->index->ihdr); > + fnd_push(fnd, n, e); > + if (!e) > + return -EINVAL; > + } > + > +ok: > + /* return offset to restore enumerator if necessary */ > + if (!n) { > + /* 'e' points in root */ > + *off = PtrOffset(&root->ihdr, e); > + } else { > + /* 'e' points in index */ > + *off = (le64_to_cpu(n->index->vbn) << indx->vbn2vbo_bits) + > + record_size + PtrOffset(&n->index->ihdr, e); > + } > + > + *entry = e; > + return 0; > +} > + > +/* > + * indx_create_allocate > + * > + * create "Allocation + Bitmap" attributes > + */ > +static int indx_create_allocate(struct ntfs_index *indx, struct ntfs_inode *ni, > + CLST *vbn) > +{ > + int err = -ENOMEM; > + struct ntfs_sb_info *sbi = ni->mi.sbi; > + struct ATTRIB *bitmap; > + struct ATTRIB *alloc; > + u32 alloc_size = ntfs_up_cluster(sbi, 1u << indx->index_bits); > + CLST len = alloc_size >> sbi->cluster_bits; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + CLST alen; > + struct runs_tree run; > + > + run_init(&run); > + > + err = attr_allocate_clusters(sbi, &run, 0, 0, len, NULL, 0, &alen, 0, > + NULL); > + if (err) > + goto out; > + > + err = ni_insert_nonresident(ni, ATTR_ALLOC, in->name, in->name_len, > + &run, 0, len, 0, &alloc, NULL); > + if (err) > + goto out1; > + > + err = ni_insert_resident(ni, QuadAlign(1), ATTR_BITMAP, in->name, > + in->name_len, &bitmap, NULL); > + if (err) > + goto out2; > + > + memcpy(&indx->alloc_run, &run, sizeof(run)); > + > + *vbn = 0; > + > + if (in->name == I30_NAME) > + ni->vfs_inode.i_size = alloc_size; > + > + return 0; > + > +out2: > + mi_remove_attr(&ni->mi, alloc); > + > +out1: > + run_deallocate(sbi, &run, false); > + > +out: > + return err; > +} > + > +/* > + * indx_add_allocate > + * > + * add clusters to index > + */ > +static int indx_add_allocate(struct ntfs_index *indx, struct ntfs_inode *ni, > + CLST *vbn) > +{ > + int err; > + size_t bit; > + u64 data_size, alloc_size; > + u64 bpb, vbpb; > + struct ATTRIB *bmp, *alloc; > + struct mft_inode *mi; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + > + err = indx_find_free(indx, ni, &bit, &bmp); > + if (err) > + goto out1; > + > + if (bit != MINUS_ONE_T) { > + bmp = NULL; > + } else { > + if (bmp->non_res) { > + bpb = le64_to_cpu(bmp->nres.data_size); > + vbpb = le64_to_cpu(bmp->nres.valid_size); > + } else { > + bpb = vbpb = le32_to_cpu(bmp->res.data_size); > + } > + > + /* Increase bitmap */ > + err = attr_set_size(ni, ATTR_BITMAP, in->name, in->name_len, > + &indx->bitmap_run, QuadAlign(bpb + 8), NULL, > + true, NULL); > + if (err) > + goto out1; > + > + bit = bpb << 3; > + } > + > + alloc = ni_find_attr(ni, NULL, NULL, ATTR_ALLOC, in->name, in->name_len, > + NULL, &mi); > + if (!alloc) { > + if (bmp) > + goto out2; > + goto out1; > + } > + > + data_size = (u64)(bit + 1) << indx->index_bits; > + alloc_size = ntfs_up_cluster(ni->mi.sbi, data_size); > + > + if (alloc_size > le64_to_cpu(alloc->nres.alloc_size)) { > + /* Increase allocation */ > + err = attr_set_size(ni, ATTR_ALLOC, in->name, in->name_len, > + &indx->alloc_run, alloc_size, &alloc_size, > + true, NULL); > + if (err) { > + if (bmp) > + goto out2; > + goto out1; > + } > + > + if (in->name == I30_NAME) > + ni->vfs_inode.i_size = alloc_size; > + } else if (data_size > le64_to_cpu(alloc->nres.data_size)) { > + alloc->nres.data_size = alloc->nres.valid_size = > + cpu_to_le64(data_size); > + mi->dirty = true; > + } > + > + *vbn = bit << indx->idx2vbn_bits; > + > + return 0; > + > +out2: > + /* Ops (no space?) */ > + attr_set_size(ni, ATTR_BITMAP, in->name, in->name_len, > + &indx->bitmap_run, bpb, &vbpb, false, NULL); > + > +out1: > + return err; > +} > + > +/* > + * indx_insert_into_root > + * > + * attempts to insert an entry into the index root > + * If necessary, it will twiddle the index b-tree. > + */ > +static int indx_insert_into_root(struct ntfs_index *indx, struct ntfs_inode *ni, > + const struct NTFS_DE *new_de, > + struct NTFS_DE *root_de, const void *ctx, > + struct ntfs_fnd *fnd) > +{ > + int err = 0; > + struct NTFS_DE *e, *e0, *re; > + struct mft_inode *mi; > + struct ATTRIB *attr; > + struct MFT_REC *rec; > + struct INDEX_HDR *hdr; > + struct indx_node *n; > + CLST new_vbn; > + __le64 *sub_vbn, t_vbn; > + u16 new_de_size; > + u32 hdr_used, hdr_total, asize, tail, used, aoff, to_move; > + u32 root_size, new_root_size; > + struct ntfs_sb_info *sbi; > + char *next; > + int ds_root; > + struct INDEX_ROOT *root, *a_root = NULL; > + > + /* Get the record this root placed in */ > + root = indx_get_root(indx, ni, &attr, &mi); > + if (!root) > + goto out; > + > + /* > + * Try easy case: > + * hdr_insert_de will succeed if there's room the root for the new entry. > + */ > + hdr = &root->ihdr; > + sbi = ni->mi.sbi; > + rec = mi->mrec; > + aoff = PtrOffset(rec, attr); > + used = le32_to_cpu(rec->used); > + new_de_size = le16_to_cpu(new_de->size); > + hdr_used = le32_to_cpu(hdr->used); > + hdr_total = le32_to_cpu(hdr->total); > + asize = le32_to_cpu(attr->size); > + next = Add2Ptr(attr, asize); > + tail = used - aoff - asize; > + root_size = le32_to_cpu(attr->res.data_size); > + > + ds_root = new_de_size + hdr_used - hdr_total; > + > + if (used + ds_root < sbi->max_bytes_per_attr) { > + /* make a room for new elements */ > + memmove(next + ds_root, next, used - aoff - asize); > + hdr->total = cpu_to_le32(hdr_total + ds_root); > + e = hdr_insert_de(indx, hdr, new_de, root_de, ctx); > + WARN_ON(!e); > + fnd_clear(fnd); > + fnd->root_de = e; > + attr->size = cpu_to_le32(asize + ds_root); > + attr->res.data_size = cpu_to_le32(root_size + ds_root); > + rec->used = cpu_to_le32(used + ds_root); > + > + return 0; > + } > + > + /* Make a copy of root attribute to restore if error */ > + a_root = ntfs_memdup(attr, asize); > + if (!a_root) { > + err = -ENOMEM; > + goto out; > + } > + > + /* copy all the non-end entries from the index root to the new buffer.*/ > + to_move = 0; > + e0 = hdr_first_de(hdr); > + > + /* Calculate the size to copy */ > + for (e = e0;; e = hdr_next_de(hdr, e)) { > + if (!e) { > + err = -EINVAL; > + goto out; > + } > + > + if (de_is_last(e)) > + break; > + to_move += le16_to_cpu(e->size); > + } > + > + n = NULL; > + if (!to_move) { > + re = NULL; > + } else { > + re = ntfs_memdup(e0, to_move); > + if (!re) { > + err = -ENOMEM; > + goto out; > + } > + } > + > + sub_vbn = NULL; > + if (de_has_vcn(e)) { > + t_vbn = de_get_vbn_le(e); > + sub_vbn = &t_vbn; > + } > + > + new_root_size = sizeof(struct INDEX_ROOT) + sizeof(struct NTFS_DE) + > + sizeof(u64); > + ds_root = new_root_size - root_size; > + > + if (ds_root > 0 && used + ds_root > sbi->max_bytes_per_attr) { > + /* make root external */ > + err = -EOPNOTSUPP; > + goto out; > + } > + > + if (ds_root) { > + memmove(next + ds_root, next, tail); > + used += ds_root; > + asize += ds_root; > + rec->used = cpu_to_le32(used); > + attr->size = cpu_to_le32(asize); > + attr->res.data_size = cpu_to_le32(new_root_size); > + mi->dirty = true; > + } > + > + /* Fill first entry (vcn will be set later) */ > + e = (struct NTFS_DE *)(root + 1); > + memset(e, 0, sizeof(struct NTFS_DE)); > + e->size = cpu_to_le16(sizeof(struct NTFS_DE) + sizeof(u64)); > + e->flags = NTFS_IE_HAS_SUBNODES | NTFS_IE_LAST; > + > + hdr->flags = 1; > + hdr->used = hdr->total = > + cpu_to_le32(new_root_size - offsetof(struct INDEX_ROOT, ihdr)); > + > + fnd->root_de = hdr_first_de(hdr); > + > + /* Create alloc and bitmap attributes (if not) */ > + if (run_is_empty(&indx->alloc_run)) { > + err = indx_create_allocate(indx, ni, &new_vbn); > + if (err) { > + /* restore root after 'indx_create_allocate' */ > + memmove(next - ds_root, next, tail); > + used -= ds_root; > + rec->used = cpu_to_le32(used); > + memcpy(attr, a_root, asize); > + goto out1; > + } > + } else { > + err = indx_add_allocate(indx, ni, &new_vbn); > + if (err) > + goto out1; > + } > + > + root = indx_get_root(indx, ni, &attr, &mi); > + if (!root) { > + err = -EINVAL; > + goto out1; > + } > + > + e = (struct NTFS_DE *)(root + 1); > + *(__le64 *)(e + 1) = cpu_to_le64(new_vbn); > + > + /* now we can create/format the new buffer and copy the entries into */ > + n = indx_new(indx, ni, new_vbn, sub_vbn); > + if (IS_ERR(n)) { > + err = PTR_ERR(n); > + goto out1; > + } > + > + hdr = &n->index->ihdr; > + hdr_used = le32_to_cpu(hdr->used); > + hdr_total = le32_to_cpu(hdr->total); > + > + /* Copy root entries into new buffer */ > + hdr_insert_head(hdr, re, to_move); > + > + /* Update bitmap attribute */ > + indx_mark_used(indx, ni, new_vbn >> indx->idx2vbn_bits); > + > + /* Check if we can insert new entry new index buffer */ > + if (hdr_used + new_de_size > hdr_total) { > + /* > + * This occurs if mft record is the same or bigger than index > + * buffer. Move all root new index and have no space to add > + * new entry classic case when mft record is 1K and index > + * buffer 4K the problem should not occurs > + */ > + ntfs_free(re); > + indx_write(indx, ni, n, 0); > + > + put_indx_node(n); > + fnd_clear(fnd); > + err = indx_insert_entry(indx, ni, new_de, ctx, fnd); > + goto out; > + } > + > + /* > + * Now root is a parent for new index buffer > + * Insert NewEntry a new buffer > + */ > + e = hdr_insert_de(indx, hdr, new_de, NULL, ctx); > + if (!e) { > + err = -EINVAL; > + goto out1; > + } > + fnd_push(fnd, n, e); > + > + /* Just write updates index into disk */ > + indx_write(indx, ni, n, 0); > + > + n = NULL; > + > +out1: > + ntfs_free(re); > + if (n) > + put_indx_node(n); > + > +out: > + ntfs_free(a_root); > + return err; > +} > + > +/* > + * indx_insert_into_buffer > + * > + * attempts to insert an entry into an Index Allocation Buffer. > + * If necessary, it will split the buffer. > + */ > +static int > +indx_insert_into_buffer(struct ntfs_index *indx, struct ntfs_inode *ni, > + struct INDEX_ROOT *root, const struct NTFS_DE *new_de, > + const void *ctx, int level, struct ntfs_fnd *fnd) > +{ > + int err; > + const struct NTFS_DE *sp; > + struct NTFS_DE *e, *de_t, *up_e = NULL; > + struct indx_node *n2 = NULL; > + struct indx_node *n1 = fnd->nodes[level]; > + struct INDEX_HDR *hdr1 = &n1->index->ihdr; > + struct INDEX_HDR *hdr2; > + u32 to_copy, used; > + CLST new_vbn; > + __le64 t_vbn, *sub_vbn; > + u16 sp_size; > + > + /* Try the most easy case */ > + e = fnd->level - 1 == level ? fnd->de[level] : NULL; > + e = hdr_insert_de(indx, hdr1, new_de, e, ctx); > + fnd->de[level] = e; > + if (e) { > + /* Just write updated index into disk */ > + indx_write(indx, ni, n1, 0); > + return 0; > + } > + > + /* > + * No space to insert into buffer. Split it. > + * To split we: > + * - Save split point ('cause index buffers will be changed) > + * - Allocate NewBuffer and copy all entries <= sp into new buffer > + * - Remove all entries (sp including) from TargetBuffer > + * - Insert NewEntry into left or right buffer (depending on sp <=> > + * NewEntry) > + * - Insert sp into parent buffer (or root) > + * - Make sp a parent for new buffer > + */ > + sp = hdr_find_split(hdr1); > + if (!sp) > + return -EINVAL; > + > + sp_size = le16_to_cpu(sp->size); > + up_e = ntfs_alloc(sp_size + sizeof(u64), 0); > + if (!up_e) > + return -ENOMEM; > + memcpy(up_e, sp, sp_size); > + > + if (!hdr1->flags) { > + up_e->flags |= NTFS_IE_HAS_SUBNODES; > + up_e->size = cpu_to_le16(sp_size + sizeof(u64)); > + sub_vbn = NULL; > + } else { > + t_vbn = de_get_vbn_le(up_e); > + sub_vbn = &t_vbn; > + } > + > + /* Allocate on disk a new index allocation buffer. */ > + err = indx_add_allocate(indx, ni, &new_vbn); > + if (err) > + goto out; > + > + /* Allocate and format memory a new index buffer */ > + n2 = indx_new(indx, ni, new_vbn, sub_vbn); > + if (IS_ERR(n2)) { > + err = PTR_ERR(n2); > + goto out; > + } > + > + hdr2 = &n2->index->ihdr; > + > + /* Make sp a parent for new buffer */ > + de_set_vbn(up_e, new_vbn); > + > + /* copy all the entries <= sp into the new buffer. */ > + de_t = hdr_first_de(hdr1); > + to_copy = PtrOffset(de_t, sp); > + hdr_insert_head(hdr2, de_t, to_copy); > + > + /* remove all entries (sp including) from hdr1 */ > + used = le32_to_cpu(hdr1->used) - to_copy - sp_size; > + memmove(de_t, Add2Ptr(sp, sp_size), used - le32_to_cpu(hdr1->de_off)); > + hdr1->used = cpu_to_le32(used); > + > + /* Insert new entry into left or right buffer (depending on sp <=> new_de) */ > + hdr_insert_de(indx, > + (*indx->cmp)(new_de + 1, le16_to_cpu(new_de->key_size), > + up_e + 1, le16_to_cpu(up_e->key_size), > + ctx) < 0 ? > + hdr2 : > + hdr1, > + new_de, NULL, ctx); > + > + indx_mark_used(indx, ni, new_vbn >> indx->idx2vbn_bits); > + > + indx_write(indx, ni, n1, 0); > + indx_write(indx, ni, n2, 0); > + > + put_indx_node(n2); > + > + /* > + * we've finished splitting everybody, so we are ready to > + * insert the promoted entry into the parent. > + */ > + if (!level) { > + /* Insert in root */ > + err = indx_insert_into_root(indx, ni, up_e, NULL, ctx, fnd); > + if (err) > + goto out; > + } else { > + /* > + * The target buffer's parent is another index buffer > + * TODO: Remove recursion > + */ > + err = indx_insert_into_buffer(indx, ni, root, up_e, ctx, > + level - 1, fnd); > + if (err) > + goto out; > + } > + > +out: > + ntfs_free(up_e); > + > + return err; > +} > + > +/* > + * indx_insert_entry > + * > + * inserts new entry into index > + */ > +int indx_insert_entry(struct ntfs_index *indx, struct ntfs_inode *ni, > + const struct NTFS_DE *new_de, const void *ctx, > + struct ntfs_fnd *fnd) > +{ > + int err; > + int diff; > + struct NTFS_DE *e; > + struct ntfs_fnd *fnd_a = NULL; > + struct INDEX_ROOT *root; > + > + if (!fnd) { > + fnd_a = fnd_get(indx); > + if (!fnd_a) { > + err = -ENOMEM; > + goto out1; > + } > + fnd = fnd_a; > + } > + > + root = indx_get_root(indx, ni, NULL, NULL); > + if (!root) { > + err = -EINVAL; > + goto out; > + } > + > + if (fnd_is_empty(fnd)) { > + /* Find the spot the tree where we want to insert the new entry. */ > + err = indx_find(indx, ni, root, new_de + 1, > + le16_to_cpu(new_de->key_size), ctx, &diff, &e, > + fnd); > + if (err) > + goto out; > + > + if (!diff) { > + err = -EEXIST; > + goto out; > + } > + } > + > + if (!fnd->level) { > + /* The root is also a leaf, so we'll insert the new entry into it. */ > + err = indx_insert_into_root(indx, ni, new_de, fnd->root_de, ctx, > + fnd); > + if (err) > + goto out; > + } else { > + /* found a leaf buffer, so we'll insert the new entry into it.*/ > + err = indx_insert_into_buffer(indx, ni, root, new_de, ctx, > + fnd->level - 1, fnd); > + if (err) > + goto out; > + } > + > +out: > + indx->changed = true; > + fnd_put(fnd_a); > +out1: > + > + return err; > +} > + > +/* > + * indx_find_buffer > + * > + * locates a buffer the tree. > + */ > +static struct indx_node *indx_find_buffer(struct ntfs_index *indx, > + struct ntfs_inode *ni, > + const struct INDEX_ROOT *root, > + __le64 vbn, struct indx_node *n) > +{ > + int err; > + const struct NTFS_DE *e; > + struct indx_node *r; > + const struct INDEX_HDR *hdr = n ? &n->index->ihdr : &root->ihdr; > + > + /* Step 1: Scan one level */ > + for (e = hdr_first_de(hdr);; e = hdr_next_de(hdr, e)) { > + if (!e) > + return ERR_PTR(-EINVAL); > + > + if (de_has_vcn(e) && vbn == de_get_vbn_le(e)) > + return n; > + > + if (de_is_last(e)) > + break; > + } > + > + /* Step2: Do recursion */ > + e = Add2Ptr(hdr, le32_to_cpu(hdr->de_off)); > + for (;;) { > + if (de_has_vcn_ex(e)) { > + err = indx_read(indx, ni, de_get_vbn(e), &n); > + if (err) > + return ERR_PTR(err); > + > + r = indx_find_buffer(indx, ni, root, vbn, n); > + if (r) > + return r; > + } > + > + if (de_is_last(e)) > + break; > + > + e = Add2Ptr(e, le16_to_cpu(e->size)); > + } > + > + return NULL; > +} > + > +/* > + * indx_shrink > + * > + * deallocates unused tail indexes > + */ > +static int indx_shrink(struct ntfs_index *indx, struct ntfs_inode *ni, > + size_t bit) > +{ > + int err = 0; > + u64 bpb, new_alloc; > + size_t nbits; > + struct ATTRIB *b; > + struct ATTR_LIST_ENTRY *le = NULL; > + const struct INDEX_NAMES *in = &s_index_names[indx->type]; > + > + b = ni_find_attr(ni, NULL, &le, ATTR_BITMAP, in->name, in->name_len, > + NULL, NULL); > + > + if (!b) > + return -ENOENT; > + > + if (!b->non_res) { > + unsigned long pos; > + const unsigned long *bm = resident_data(b); > + > + nbits = le32_to_cpu(b->res.data_size) * 8; > + > + if (bit >= nbits) > + return 0; > + > + pos = find_next_bit(bm, nbits, bit); > + if (pos < nbits) > + return 0; > + } else { > + size_t used = MINUS_ONE_T; > + > + nbits = le64_to_cpu(b->nres.data_size) * 8; > + > + if (bit >= nbits) > + return 0; > + > + err = scan_nres_bitmap(ni->mi.sbi, b, &indx->bitmap_run, bit, > + &scan_for_used, &used); > + if (err) > + return err; > + > + if (used != MINUS_ONE_T) > + return 0; > + } > + > + new_alloc = (u64)bit << indx->index_bits; > + > + err = attr_set_size(ni, ATTR_ALLOC, in->name, in->name_len, > + &indx->alloc_run, new_alloc, &new_alloc, false, > + NULL); > + if (err) > + return err; > + > + if (in->name == I30_NAME) > + ni->vfs_inode.i_size = new_alloc; > + > + bpb = bitmap_size(bit); > + if (bpb * 8 == nbits) > + return 0; > + > + err = attr_set_size(ni, ATTR_BITMAP, in->name, in->name_len, > + &indx->bitmap_run, bpb, &bpb, false, NULL); > + > + return err; > +} > + > +static int indx_free_children(struct ntfs_index *indx, struct ntfs_inode *ni, > + const struct NTFS_DE *e, bool trim) > +{ > + int err; > + struct indx_node *n; > + struct INDEX_HDR *hdr; > + CLST vbn = de_get_vbn(e); > + size_t i; > + > + err = indx_read(indx, ni, vbn, &n); > + if (err) > + return err; > + > + hdr = &n->index->ihdr; > + /* First, recurse into the children, if any.*/ > + if (hdr_has_subnode(hdr)) { > + for (e = hdr_first_de(hdr); e; e = hdr_next_de(hdr, e)) { > + indx_free_children(indx, ni, e, false); > + if (de_is_last(e)) > + break; > + } > + } > + > + put_indx_node(n); > + > + i = vbn >> indx->idx2vbn_bits; > + /* We've gotten rid of the children; add this buffer to the free list. */ > + indx_mark_free(indx, ni, i); > + > + if (!trim) > + return 0; > + > + /* > + * If there are no used indexes after current free index > + * then we can truncate allocation and bitmap > + * Use bitmap to estimate the case > + */ > + indx_shrink(indx, ni, i + 1); > + return 0; > +} > + > +/* > + * indx_get_entry_to_replace > + * > + * finds a replacement entry for a deleted entry > + * always returns a node entry: > + * NTFS_IE_HAS_SUBNODES is set the flags and the size includes the sub_vcn > + */ > +static int indx_get_entry_to_replace(struct ntfs_index *indx, > + struct ntfs_inode *ni, > + const struct NTFS_DE *de_next, > + struct NTFS_DE **de_to_replace, > + struct ntfs_fnd *fnd) > +{ > + int err; > + int level = -1; > + CLST vbn; > + struct NTFS_DE *e, *te, *re; > + struct indx_node *n; > + struct INDEX_BUFFER *ib; > + > + *de_to_replace = NULL; > + > + /* Find first leaf entry down from de_next */ > + vbn = de_get_vbn(de_next); > + for (;;) { > + n = NULL; > + err = indx_read(indx, ni, vbn, &n); > + if (err) > + goto out; > + > + e = hdr_first_de(&n->index->ihdr); > + fnd_push(fnd, n, e); > + > + if (!de_is_last(e)) { > + /* > + * This buffer is non-empty, so its first entry could be used as the > + * replacement entry. > + */ > + level = fnd->level - 1; > + } > + > + if (!de_has_vcn(e)) > + break; > + > + /* This buffer is a node. Continue to go down */ > + vbn = de_get_vbn(e); > + } > + > + if (level == -1) > + goto out; > + > + n = fnd->nodes[level]; > + te = hdr_first_de(&n->index->ihdr); > + /* Copy the candidate entry into the replacement entry buffer. */ > + re = ntfs_alloc(le16_to_cpu(te->size) + sizeof(u64), 0); > + if (!re) { > + err = -ENOMEM; > + goto out; > + } > + > + *de_to_replace = re; > + memcpy(re, te, le16_to_cpu(te->size)); > + > + if (!de_has_vcn(re)) { > + /* > + * The replacement entry we found doesn't have a sub_vcn. increase its size > + * to hold one. > + */ > + le16_add_cpu(&re->size, sizeof(u64)); > + re->flags |= NTFS_IE_HAS_SUBNODES; > + } else { > + /* > + * The replacement entry we found was a node entry, which means that all > + * its child buffers are empty. Return them to the free pool. > + */ > + indx_free_children(indx, ni, te, true); > + } > + > + /* > + * Expunge the replacement entry from its former location, > + * and then write that buffer. > + */ > + ib = n->index; > + e = hdr_delete_de(&ib->ihdr, te); > + > + fnd->de[level] = e; > + indx_write(indx, ni, n, 0); > + > + /* Check to see if this action created an empty leaf. */ > + if (ib_is_leaf(ib) && ib_is_empty(ib)) > + return 0; > + > +out: > + fnd_clear(fnd); > + > + return err; > +} > + > +/* > + * indx_delete_entry > + * > + * deletes an entry from the index. > + */ > +int indx_delete_entry(struct ntfs_index *indx, struct ntfs_inode *ni, > + const void *key, u32 key_len, const void *ctx) > +{ > + int err, diff; > + struct INDEX_ROOT *root; > + struct INDEX_HDR *hdr; > + struct ntfs_fnd *fnd, *fnd2; > + struct INDEX_BUFFER *ib; > + struct NTFS_DE *e, *re, *next, *prev, *me; > + struct indx_node *n, *n2d = NULL; > + __le64 sub_vbn; > + int level, level2; > + struct ATTRIB *attr; > + struct mft_inode *mi; > + u32 e_size, root_size, new_root_size; > + size_t trim_bit; > + const struct INDEX_NAMES *in; > + > + fnd = fnd_get(indx); > + if (!fnd) { > + err = -ENOMEM; > + goto out2; > + } > + > + fnd2 = fnd_get(NULL); > + if (!fnd2) { > + err = -ENOMEM; > + goto out1; > + } > + > + root = indx_get_root(indx, ni, &attr, &mi); > + if (!root) { > + err = -EINVAL; > + goto out; > + } > + > + /* Locate the entry to remove. */ > + err = indx_find(indx, ni, root, key, key_len, ctx, &diff, &e, fnd); > + if (err) > + goto out; > + > + if (!e || diff) { > + err = -ENOENT; > + goto out; > + } > + > + level = fnd->level; > + > + if (level) { > + n = fnd->nodes[level - 1]; > + e = fnd->de[level - 1]; > + ib = n->index; > + hdr = &ib->ihdr; > + } else { > + hdr = &root->ihdr; > + e = fnd->root_de; > + n = NULL; > + } > + > + e_size = le16_to_cpu(e->size); > + > + if (!de_has_vcn_ex(e)) { > + /* The entry to delete is a leaf, so we can just rip it out */ > + hdr_delete_de(hdr, e); > + > + if (!level) { > + hdr->total = hdr->used; > + > + /* Shrink resident root attribute */ > + mi_resize_attr(mi, attr, 0 - e_size); > + goto out; > + } > + > + indx_write(indx, ni, n, 0); > + > + /* > + * Check to see if removing that entry made > + * the leaf empty. > + */ > + if (ib_is_leaf(ib) && ib_is_empty(ib)) { > + fnd_pop(fnd); > + fnd_push(fnd2, n, e); > + } > + } else { > + /* > + * The entry we wish to delete is a node buffer, so we > + * have to find a replacement for it. > + */ > + next = de_get_next(e); > + > + err = indx_get_entry_to_replace(indx, ni, next, &re, fnd2); > + if (err) > + goto out; > + > + if (re) { > + de_set_vbn_le(re, de_get_vbn_le(e)); > + hdr_delete_de(hdr, e); > + > + err = level ? indx_insert_into_buffer(indx, ni, root, > + re, ctx, > + fnd->level - 1, > + fnd) : > + indx_insert_into_root(indx, ni, re, e, > + ctx, fnd); > + ntfs_free(re); > + > + if (err) > + goto out; > + } else { > + /* > + * There is no replacement for the current entry. > + * This means that the subtree rooted at its node is empty, > + * and can be deleted, which turn means that the node can > + * just inherit the deleted entry sub_vcn > + */ > + indx_free_children(indx, ni, next, true); > + > + de_set_vbn_le(next, de_get_vbn_le(e)); > + hdr_delete_de(hdr, e); > + if (level) { > + indx_write(indx, ni, n, 0); > + } else { > + hdr->total = hdr->used; > + > + /* Shrink resident root attribute */ > + mi_resize_attr(mi, attr, 0 - e_size); > + } > + } > + } > + > + /* Delete a branch of tree */ > + if (!fnd2 || !fnd2->level) > + goto out; > + > + /* Reinit root 'cause it can be changed */ > + root = indx_get_root(indx, ni, &attr, &mi); > + if (!root) { > + err = -EINVAL; > + goto out; > + } > + > + n2d = NULL; > + sub_vbn = fnd2->nodes[0]->index->vbn; > + level2 = 0; > + level = fnd->level; > + > + hdr = level ? &fnd->nodes[level - 1]->index->ihdr : &root->ihdr; > + > + /* Scan current level */ > + for (e = hdr_first_de(hdr);; e = hdr_next_de(hdr, e)) { > + if (!e) { > + err = -EINVAL; > + goto out; > + } > + > + if (de_has_vcn(e) && sub_vbn == de_get_vbn_le(e)) > + break; > + > + if (de_is_last(e)) { > + e = NULL; > + break; > + } > + } > + > + if (!e) { > + /* Do slow search from root */ > + struct indx_node *in; > + > + fnd_clear(fnd); > + > + in = indx_find_buffer(indx, ni, root, sub_vbn, NULL); > + if (IS_ERR(in)) { > + err = PTR_ERR(in); > + goto out; > + } > + > + if (in) > + fnd_push(fnd, in, NULL); > + } > + > + /* Merge fnd2 -> fnd */ > + for (level = 0; level < fnd2->level; level++) { > + fnd_push(fnd, fnd2->nodes[level], fnd2->de[level]); > + fnd2->nodes[level] = NULL; > + } > + fnd2->level = 0; > + > + hdr = NULL; > + for (level = fnd->level; level; level--) { > + struct indx_node *in = fnd->nodes[level - 1]; > + > + ib = in->index; > + if (ib_is_empty(ib)) { > + sub_vbn = ib->vbn; > + } else { > + hdr = &ib->ihdr; > + n2d = in; > + level2 = level; > + break; > + } > + } > + > + if (!hdr) > + hdr = &root->ihdr; > + > + e = hdr_first_de(hdr); > + if (!e) { > + err = -EINVAL; > + goto out; > + } > + > + if (hdr != &root->ihdr || !de_is_last(e)) { > + prev = NULL; > + while (!de_is_last(e)) { > + if (de_has_vcn(e) && sub_vbn == de_get_vbn_le(e)) > + break; > + prev = e; > + e = hdr_next_de(hdr, e); > + if (!e) { > + err = -EINVAL; > + goto out; > + } > + } > + > + if (sub_vbn != de_get_vbn_le(e)) { > + /* > + * Didn't find the parent entry, although this buffer is the parent trail. > + * Something is corrupt. > + */ > + err = -EINVAL; > + goto out; > + } > + > + if (de_is_last(e)) { > + /* > + * Since we can't remove the end entry, we'll remove its > + * predecessor instead. This means we have to transfer the > + * predecessor's sub_vcn to the end entry. > + * Note: that this index block is not empty, so the > + * predecessor must exist > + */ > + if (!prev) { > + err = -EINVAL; > + goto out; > + } > + > + if (de_has_vcn(prev)) { > + de_set_vbn_le(e, de_get_vbn_le(prev)); > + } else if (de_has_vcn(e)) { > + le16_sub_cpu(&e->size, sizeof(u64)); > + e->flags &= ~NTFS_IE_HAS_SUBNODES; > + le32_sub_cpu(&hdr->used, sizeof(u64)); > + } > + e = prev; > + } > + > + /* > + * Copy the current entry into a temporary buffer (stripping off its > + * down-pointer, if any) and delete it from the current buffer or root, > + * as appropriate. > + */ > + e_size = le16_to_cpu(e->size); > + me = ntfs_memdup(e, e_size); > + if (!me) { > + err = -ENOMEM; > + goto out; > + } > + > + if (de_has_vcn(me)) { > + me->flags &= ~NTFS_IE_HAS_SUBNODES; > + le16_sub_cpu(&me->size, sizeof(u64)); > + } > + > + hdr_delete_de(hdr, e); > + > + if (hdr == &root->ihdr) { > + level = 0; > + hdr->total = hdr->used; > + > + /* Shrink resident root attribute */ > + mi_resize_attr(mi, attr, 0 - e_size); > + } else { > + indx_write(indx, ni, n2d, 0); > + level = level2; > + } > + > + /* Mark unused buffers as free */ > + trim_bit = -1; > + for (; level < fnd->level; level++) { > + ib = fnd->nodes[level]->index; > + if (ib_is_empty(ib)) { > + size_t k = le64_to_cpu(ib->vbn) >> > + indx->idx2vbn_bits; > + > + indx_mark_free(indx, ni, k); > + if (k < trim_bit) > + trim_bit = k; > + } > + } > + > + fnd_clear(fnd); > + /*fnd->root_de = NULL;*/ > + > + /* > + * Re-insert the entry into the tree. > + * Find the spot the tree where we want to insert the new entry. > + */ > + err = indx_insert_entry(indx, ni, me, ctx, fnd); > + ntfs_free(me); > + if (err) > + goto out; > + > + if (trim_bit != -1) > + indx_shrink(indx, ni, trim_bit); > + } else { > + /* > + * This tree needs to be collapsed down to an empty root. > + * Recreate the index root as an empty leaf and free all the bits the > + * index allocation bitmap. > + */ > + fnd_clear(fnd); > + fnd_clear(fnd2); > + > + in = &s_index_names[indx->type]; > + > + err = attr_set_size(ni, ATTR_ALLOC, in->name, in->name_len, > + &indx->alloc_run, 0, NULL, false, NULL); > + err = ni_remove_attr(ni, ATTR_ALLOC, in->name, in->name_len, > + false, NULL); > + run_close(&indx->alloc_run); > + > + err = attr_set_size(ni, ATTR_BITMAP, in->name, in->name_len, > + &indx->bitmap_run, 0, NULL, false, NULL); > + err = ni_remove_attr(ni, ATTR_BITMAP, in->name, in->name_len, > + false, NULL); > + run_close(&indx->bitmap_run); > + > + root = indx_get_root(indx, ni, &attr, &mi); > + if (!root) { > + err = -EINVAL; > + goto out; > + } > + > + root_size = le32_to_cpu(attr->res.data_size); > + new_root_size = > + sizeof(struct INDEX_ROOT) + sizeof(struct NTFS_DE); > + > + if (new_root_size != root_size && > + !mi_resize_attr(mi, attr, new_root_size - root_size)) { > + err = -EINVAL; > + goto out; > + } > + > + /* Fill first entry */ > + e = (struct NTFS_DE *)(root + 1); > + e->ref.low = 0; > + e->ref.high = 0; > + e->ref.seq = 0; > + e->size = cpu_to_le16(sizeof(struct NTFS_DE)); > + e->flags = NTFS_IE_LAST; // 0x02 > + e->key_size = 0; > + e->res = 0; > + > + hdr = &root->ihdr; > + hdr->flags = 0; > + hdr->used = hdr->total = cpu_to_le32( > + new_root_size - offsetof(struct INDEX_ROOT, ihdr)); > + mi->dirty = true; > + > + if (in->name == I30_NAME) > + ni->vfs_inode.i_size = 0; > + } > + > +out: > + fnd_put(fnd2); > +out1: > + indx->changed = true; > + fnd_put(fnd); > + > +out2: > + return err; > +} > + > +int indx_update_dup(struct ntfs_inode *ni, struct ntfs_sb_info *sbi, > + const struct ATTR_FILE_NAME *fname, > + const struct NTFS_DUP_INFO *dup, int sync) > +{ > + int err, diff; > + struct NTFS_DE *e = NULL; > + struct ATTR_FILE_NAME *e_fname; > + struct ntfs_fnd *fnd; > + struct INDEX_ROOT *root; > + struct mft_inode *mi; > + struct ntfs_index *indx = &ni->dir; > + > + fnd = fnd_get(indx); > + if (!fnd) { > + err = -ENOMEM; > + goto out1; > + } > + > + root = indx_get_root(indx, ni, NULL, &mi); > + if (!root) { > + err = -EINVAL; > + goto out; > + } > + > + /* Find entries tree and on disk */ > + err = indx_find(indx, ni, root, fname, fname_full_size(fname), sbi, > + &diff, &e, fnd); > + if (err) > + goto out; > + > + if (!e) { > + err = -EINVAL; > + goto out; > + } > + > + if (diff) { > + err = -EINVAL; > + goto out; > + } > + > + e_fname = (struct ATTR_FILE_NAME *)(e + 1); > + > + if (!memcmp(&e_fname->dup, dup, sizeof(*dup))) { > + /* nothing to update in index! Try to avoid this call */ > + goto out; > + } > + > + memcpy(&e_fname->dup, dup, sizeof(*dup)); > + > + if (fnd->level) { > + err = indx_write(indx, ni, fnd->nodes[fnd->level - 1], sync); > + } else if (sync) { > + mi->dirty = true; > + err = mi_write(mi, 1); > + } else { > + mi->dirty = true; > + mark_inode_dirty(&ni->vfs_inode); > + } > + > +out: > + fnd_put(fnd); > + > +out1: > + return err; > +} > diff --git a/fs/ntfs3/inode.c b/fs/ntfs3/inode.c > new file mode 100644 > index 000000000000..5de85b7f909d > --- /dev/null > +++ b/fs/ntfs3/inode.c > @@ -0,0 +1,1998 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * linux/fs/ntfs3/inode.c > + * > + * Copyright (C) 2019-2020 Paragon Software GmbH, All rights reserved. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "debug.h" > +#include "ntfs.h" > +#include "ntfs_fs.h" > + > +/* > + * ntfs_read_mft > + * > + * reads record and parses MFT > + */ > +static struct inode *ntfs_read_mft(struct inode *inode, > + const struct cpu_str *name, > + const struct MFT_REF *ref) > +{ > + int err = 0; > + struct ntfs_inode *ni = ntfs_i(inode); > + struct super_block *sb = inode->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + mode_t mode = 0; > + struct ATTR_STD_INFO5 *std5 = NULL; > + struct ATTR_LIST_ENTRY *le; > + struct ATTRIB *attr; > + bool is_match = false; > + bool is_root = false; > + bool is_dir; > + unsigned long ino = inode->i_ino; > + u32 rp_fa = 0, asize, t32; > + u16 roff, rsize, names = 0; > + const struct ATTR_FILE_NAME *fname = NULL; > + const struct INDEX_ROOT *root; > + struct REPARSE_DATA_BUFFER rp; // 0x18 bytes > + u64 t64; > + struct MFT_REC *rec; > + struct runs_tree *run; > + > + inode->i_op = NULL; > + > + err = mi_init(&ni->mi, sbi, ino); > + if (err) > + goto out; > + > + if (!sbi->mft.ni && ino == MFT_REC_MFT && !sb->s_root) { > + t64 = sbi->mft.lbo >> sbi->cluster_bits; > + t32 = bytes_to_cluster(sbi, MFT_REC_VOL * sbi->record_size); > + sbi->mft.ni = ni; > + init_rwsem(&ni->file.run_lock); > + > + if (!run_add_entry(&ni->file.run, 0, t64, t32)) { > + err = -ENOMEM; > + goto out; > + } > + } > + > + err = mi_read(&ni->mi, ino == MFT_REC_MFT); > + > + if (err) > + goto out; > + > + rec = ni->mi.mrec; > + > + if (sbi->flags & NTFS_FLAGS_LOG_REPLAYING) { > + ; > + } else if (ref->seq != rec->seq) { > + err = -EINVAL; > + ntfs_err(sb, "MFT: r=%lx, expect seq=%x instead of %x!", ino, > + le16_to_cpu(ref->seq), le16_to_cpu(rec->seq)); > + goto out; > + } else if (!is_rec_inuse(rec)) { > + err = -EINVAL; > + ntfs_err(sb, "Inode r=%x is not in use!", (u32)ino); > + goto out; > + } > + > + if (le32_to_cpu(rec->total) != sbi->record_size) { > + // bad inode? > + err = -EINVAL; > + goto out; > + } > + > + if (!is_rec_base(rec)) > + goto Ok; > + > + /* record should contain $I30 root */ > + is_dir = rec->flags & RECORD_FLAG_DIR; > + > + inode->i_generation = le16_to_cpu(rec->seq); > + > + /* Enumerate all struct Attributes MFT */ > + le = NULL; > + attr = NULL; > + > + /* > + * to reduce tab pressure use goto instead of > + * while( (attr = ni_enum_attr_ex(ni, attr, &le) )) > + */ > +next_attr: > + run = NULL; > + err = -EINVAL; > + attr = ni_enum_attr_ex(ni, attr, &le); > + if (!attr) > + goto end_enum; > + > + if (le && le->vcn) { > + /* This is non primary attribute segment. Ignore if not MFT */ > + if (ino != MFT_REC_MFT || attr->type != ATTR_DATA) > + goto next_attr; > + > + run = &ni->file.run; > + asize = le32_to_cpu(attr->size); > + goto attr_unpack_run; > + } > + > + roff = attr->non_res ? 0 : le16_to_cpu(attr->res.data_off); > + rsize = attr->non_res ? 0 : le32_to_cpu(attr->res.data_size); > + asize = le32_to_cpu(attr->size); > + > + switch (attr->type) { > + case ATTR_STD: > + if (attr->non_res || > + asize < sizeof(struct ATTR_STD_INFO) + roff || > + rsize < sizeof(struct ATTR_STD_INFO)) > + goto out; > + > + if (std5) > + goto next_attr; > + > + std5 = Add2Ptr(attr, roff); > + > +#ifdef STATX_BTIME > + nt2kernel(std5->cr_time, &ni->i_crtime); > +#endif > + nt2kernel(std5->a_time, &inode->i_atime); > + nt2kernel(std5->c_time, &inode->i_ctime); > + nt2kernel(std5->m_time, &inode->i_mtime); > + > + ni->std_fa = std5->fa; > + > + if (asize >= sizeof(struct ATTR_STD_INFO5) + roff && > + rsize >= sizeof(struct ATTR_STD_INFO5)) > + ni->std_security_id = std5->security_id; > + goto next_attr; > + > + case ATTR_LIST: > + if (attr->name_len || le || ino == MFT_REC_LOG) > + goto out; > + > + err = ntfs_load_attr_list(ni, attr); > + if (err) > + goto out; > + > + le = NULL; > + attr = NULL; > + goto next_attr; > + > + case ATTR_NAME: > + if (attr->non_res || asize < SIZEOF_ATTRIBUTE_FILENAME + roff || > + rsize < SIZEOF_ATTRIBUTE_FILENAME) > + goto out; > + > + fname = Add2Ptr(attr, roff); > + if (fname->type == FILE_NAME_DOS) > + goto next_attr; > + > + names += 1; > + if (name && name->len == fname->name_len && > + !ntfs_cmp_names_cpu(name, (struct le_str *)&fname->name_len, > + NULL)) > + is_match = true; > + > + goto next_attr; > + > + case ATTR_DATA: > + if (is_dir) { > + /* ignore data attribute in dir record */ > + goto next_attr; > + } > + > + if (ino == MFT_REC_BADCLUST && !attr->non_res) > + goto next_attr; > + > + if (attr->name_len && > + ((ino != MFT_REC_BADCLUST || !attr->non_res || > + attr->name_len != ARRAY_SIZE(BAD_NAME) || > + memcmp(attr_name(attr), BAD_NAME, sizeof(BAD_NAME))) && > + (ino != MFT_REC_SECURE || !attr->non_res || > + attr->name_len != ARRAY_SIZE(SDS_NAME) || > + memcmp(attr_name(attr), SDS_NAME, sizeof(SDS_NAME))))) { > + /* file contains stream attribute. ignore it */ > + goto next_attr; > + } > + > + if (is_attr_sparsed(attr)) > + ni->std_fa |= FILE_ATTRIBUTE_SPARSE_FILE; > + else > + ni->std_fa &= ~FILE_ATTRIBUTE_SPARSE_FILE; > + > + if (is_attr_compressed(attr)) > + ni->std_fa |= FILE_ATTRIBUTE_COMPRESSED; > + else > + ni->std_fa &= ~FILE_ATTRIBUTE_COMPRESSED; > + > + if (is_attr_encrypted(attr)) > + ni->std_fa |= FILE_ATTRIBUTE_ENCRYPTED; > + else > + ni->std_fa &= ~FILE_ATTRIBUTE_ENCRYPTED; > + > + if (!attr->non_res) { > + ni->i_valid = inode->i_size = rsize; > + inode_set_bytes(inode, rsize); > + t32 = asize; > + } else { > + t32 = le16_to_cpu(attr->nres.run_off); > + } > + > + mode = S_IFREG | (0777 & sbi->options.fs_fmask_inv); > + > + if (!attr->non_res) { > + ni->ni_flags |= NI_FLAG_RESIDENT; > + goto next_attr; > + } > + > + inode_set_bytes(inode, attr_ondisk_size(attr)); > + > + ni->i_valid = le64_to_cpu(attr->nres.valid_size); > + inode->i_size = le64_to_cpu(attr->nres.data_size); > + if (!attr->nres.alloc_size) > + goto next_attr; > + > + run = ino == MFT_REC_BITMAP ? &sbi->used.bitmap.run : > + &ni->file.run; > + break; > + > + case ATTR_ROOT: > + if (attr->non_res) > + goto out; > + > + root = Add2Ptr(attr, roff); > + is_root = true; > + > + if (attr->name_len != ARRAY_SIZE(I30_NAME) || > + memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME))) > + goto next_attr; > + > + if (root->type != ATTR_NAME || > + root->rule != NTFS_COLLATION_TYPE_FILENAME) > + goto out; > + > + if (!is_dir) > + goto next_attr; > + > + ni->ni_flags |= NI_FLAG_DIR; > + > + err = indx_init(&ni->dir, sbi, attr, INDEX_MUTEX_I30); > + if (err) > + goto out; > + > + mode = sb->s_root ? > + (S_IFDIR | (0777 & sbi->options.fs_dmask_inv)) : > + (S_IFDIR | 0777); > + goto next_attr; > + > + case ATTR_ALLOC: > + if (!is_root || attr->name_len != ARRAY_SIZE(I30_NAME) || > + memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME))) > + goto next_attr; > + > + inode->i_size = le64_to_cpu(attr->nres.data_size); > + ni->i_valid = le64_to_cpu(attr->nres.valid_size); > + inode_set_bytes(inode, le64_to_cpu(attr->nres.alloc_size)); > + > + run = &ni->dir.alloc_run; > + break; > + > + case ATTR_BITMAP: > + if (ino == MFT_REC_MFT) { > + if (!attr->non_res) > + goto out; > +#ifndef NTFS3_64BIT_CLUSTER > + /* 0x20000000 = 2^32 / 8 */ > + if (le64_to_cpu(attr->nres.alloc_size) >= 0x20000000) > + goto out; > +#endif > + run = &sbi->mft.bitmap.run; > + break; > + } else if (is_dir && attr->name_len == ARRAY_SIZE(I30_NAME) && > + !memcmp(attr_name(attr), I30_NAME, > + sizeof(I30_NAME)) && > + attr->non_res) { > + run = &ni->dir.bitmap_run; > + break; > + } > + goto next_attr; > + > + case ATTR_REPARSE: > + if (attr->name_len) > + goto next_attr; > + > + rp_fa = ni_parse_reparse(ni, attr, &rp); > + switch (rp_fa) { > + case REPARSE_LINK: > + if (!attr->non_res) { > + inode->i_size = rsize; > + inode_set_bytes(inode, rsize); > + t32 = asize; > + } else { > + inode->i_size = > + le64_to_cpu(attr->nres.data_size); > + t32 = le16_to_cpu(attr->nres.run_off); > + } > + > + /* Looks like normal symlink */ > + ni->i_valid = inode->i_size; > + > + /* Clear directory bit */ > + if (ni->ni_flags & NI_FLAG_DIR) { > + indx_clear(&ni->dir); > + memset(&ni->dir, 0, sizeof(ni->dir)); > + ni->ni_flags &= ~NI_FLAG_DIR; > + } else { > + run_close(&ni->file.run); > + } > + mode = S_IFLNK | 0777; > + is_dir = false; > + if (attr->non_res) { > + run = &ni->file.run; > + goto attr_unpack_run; // double break > + } > + break; > + > + case REPARSE_COMPRESSED: > + break; > + > + case REPARSE_DEDUPLICATED: > + break; > + } > + goto next_attr; > + > + case ATTR_EA_INFO: > + if (!attr->name_len && > + resident_data_ex(attr, sizeof(struct EA_INFO))) > + ni->ni_flags |= NI_FLAG_EA; > + goto next_attr; > + > + default: > + goto next_attr; > + } > + > +attr_unpack_run: > + roff = le16_to_cpu(attr->nres.run_off); > + > + err = run_unpack_ex(run, sbi, ino, le64_to_cpu(attr->nres.svcn), > + le64_to_cpu(attr->nres.evcn), Add2Ptr(attr, roff), > + asize - roff); > + if (err < 0) > + goto out; > + err = 0; > + goto next_attr; > + > +end_enum: > + > + if (!std5) > + goto out; > + > + if (!is_match && name) { > + /* reuse rec as buffer for ascii name */ > + err = -ENOENT; > + goto out; > + } > + > + if (std5->fa & FILE_ATTRIBUTE_READONLY) > + mode &= ~0222; > + > + /* Setup 'uid' and 'gid' */ > + inode->i_uid = sbi->options.fs_uid; > + inode->i_gid = sbi->options.fs_gid; > + > + if (!names) { > + err = -EINVAL; > + goto out; > + } > + > + if (S_ISDIR(mode)) { > + ni->std_fa |= FILE_ATTRIBUTE_DIRECTORY; > + > + /* > + * dot and dot-dot should be included in count but was not > + * included in enumeration. > + * Usually a hard links to directories are disabled > + */ > + set_nlink(inode, 1); > + inode->i_op = &ntfs_dir_inode_operations; > + inode->i_fop = &ntfs_dir_operations; > + ni->i_valid = 0; > + } else if (S_ISLNK(mode)) { > + ni->std_fa &= ~FILE_ATTRIBUTE_DIRECTORY; > + inode->i_op = &ntfs_link_inode_operations; > + inode->i_fop = NULL; > + inode_nohighmem(inode); // ?? > + set_nlink(inode, names); > + } else if (S_ISREG(mode)) { > + ni->std_fa &= ~FILE_ATTRIBUTE_DIRECTORY; > + > + set_nlink(inode, names); > + > + inode->i_op = &ntfs_file_inode_operations; > + inode->i_fop = &ntfs_file_operations; > + inode->i_mapping->a_ops = > + is_compressed(ni) ? &ntfs_aops_cmpr : &ntfs_aops; > + > + if (ino != MFT_REC_MFT) > + init_rwsem(&ni->file.run_lock); > + } else if (fname && fname->home.low == cpu_to_le32(MFT_REC_EXTEND) && > + fname->home.seq == cpu_to_le16(MFT_REC_EXTEND)) { > + /* Records in $Extend are not a files or general directories */ > + } else { > + err = -EINVAL; > + goto out; > + } > + > + if ((sbi->options.sys_immutable && > + (std5->fa & FILE_ATTRIBUTE_SYSTEM)) && > + !S_ISFIFO(mode) && !S_ISSOCK(mode) && !S_ISLNK(mode)) { > + inode->i_flags |= S_IMMUTABLE; > + } else { > + inode->i_flags &= ~S_IMMUTABLE; > + } > + > + inode->i_mode = mode; > + > +Ok: > + if (ino == MFT_REC_MFT && !sb->s_root) > + sbi->mft.ni = NULL; > + > + unlock_new_inode(inode); > + > + return inode; > + > +out: > + if (ino == MFT_REC_MFT && !sb->s_root) > + sbi->mft.ni = NULL; > + > + iget_failed(inode); > + > + return ERR_PTR(err); > +} > + > +/* returns 1 if match */ > +static int ntfs_test_inode(struct inode *inode, const struct MFT_REF *ref) > +{ > + return ino_get(ref) == inode->i_ino; > +} > + > +static int ntfs_set_inode(struct inode *inode, const struct MFT_REF *ref) > +{ > + inode->i_ino = ino_get(ref); > + > + return 0; > +} > + > +struct inode *ntfs_iget5(struct super_block *sb, const struct MFT_REF *ref, > + const struct cpu_str *name) > +{ > + struct inode *inode; > + > + inode = iget5_locked(sb, ino_get(ref), > + (int (*)(struct inode *, void *))ntfs_test_inode, > + (int (*)(struct inode *, void *))ntfs_set_inode, > + (void *)ref); > + if (unlikely(!inode)) > + return ERR_PTR(-ENOMEM); > + > + /* If this is a freshly allocated inode, need to read it now. */ > + if (inode->i_state & I_NEW) > + inode = ntfs_read_mft(inode, name, ref); > + else if (ref->seq != ntfs_i(inode)->mi.mrec->seq) > + make_bad_inode(inode); > + > + return inode; > +} > + > +enum get_block_ctx { > + GET_BLOCK_GENERAL = 0, > + GET_BLOCK_WRITE_BEGIN = 1, > + GET_BLOCK_DIRECT_IO_R = 2, > + GET_BLOCK_DIRECT_IO_W = 3, > + GET_BLOCK_BMAP = 4, > +}; > + > +static noinline int ntfs_get_block_vbo(struct inode *inode, u64 vbo, > + struct buffer_head *bh, int create, > + enum get_block_ctx ctx) > +{ > + struct super_block *sb = inode->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct ntfs_inode *ni = ntfs_i(inode); > + u64 bytes, lbo; > + u32 off; > + int err; > + CLST vcn, lcn, len; > + u8 cluster_bits = sbi->cluster_bits; > + bool new; > + > + /*clear previous state*/ > + clear_buffer_new(bh); > + clear_buffer_uptodate(bh); > + > + /* direct write uses 'create=0'*/ > + if (!create && vbo >= ni->i_valid) > + return 0; > + > + if (vbo >= inode->i_size) > + return 0; > + > + vcn = vbo >> cluster_bits; > + off = vbo & sbi->cluster_mask; > + new = false; > + > + err = attr_data_get_block(ni, vcn, 1, &lcn, &len, create ? &new : NULL); > + if (err) > + goto out; > + > + if (!len) > + return 0; > + > + bytes = ((u64)len << cluster_bits) - off; > + > + if (lcn == SPARSE_LCN) { > + if (!create) { > + if (bh->b_size > bytes) > + bh->b_size = bytes; > + > + return 0; > + } > + WARN_ON(1); > + } > + > + WARN_ON(lcn == RESIDENT_LCN); > + > + if (new) { > + u32 allocated = len * sbi->cluster_size; > + > + set_buffer_new(bh); > + if (allocated > sb->s_blocksize) > + ntfs_sparse_cluster(inode, bh->b_page, > + (loff_t)vcn << sbi->cluster_bits, > + allocated); > + } > + > + lbo = ((u64)lcn << cluster_bits) + off; > + > + set_buffer_mapped(bh); > + bh->b_bdev = sb->s_bdev; > + bh->b_blocknr = lbo >> sb->s_blocksize_bits; > + > + if (ctx == GET_BLOCK_DIRECT_IO_W) { > + /*ntfs_direct_IO will update ni->i_valid */ > + if (vbo >= ni->i_valid) > + set_buffer_new(bh); > + } else if (create && ctx == GET_BLOCK_WRITE_BEGIN && > + vbo + bh->b_size > ni->i_valid) { > + u32 voff = ni->i_valid > vbo ? (ni->i_valid - vbo) : 0; > + struct page *page = bh->b_page; > + > + off = bh_offset(bh); > + zero_user_segment(page, off + voff, off + bh->b_size); > + set_buffer_uptodate(bh); > + ni->i_valid = vbo + bh->b_size; > + > + /* ntfs_write_end will update ni->i_valid*/ > + } else if (create) { > + /*normal write*/ > + if (vbo >= ni->i_valid) { > + set_buffer_new(bh); > + if (bytes > bh->b_size) > + bytes = bh->b_size; > + ni->i_valid = vbo + bytes; > + mark_inode_dirty(inode); > + } > + } else if (vbo >= ni->i_valid) { > + /* read out of valid data*/ > + /* should never be here 'cause already checked */ > + clear_buffer_mapped(bh); > + } else if (vbo + bytes <= ni->i_valid) { > + /* normal read */ > + } else { > + /* here: vbo <= ni->i_valid && ni->i_valid < vbo + bytes */ > + u64 valid_up = > + (ni->i_valid + PAGE_SIZE - 1) & ~(u64)(PAGE_SIZE - 1); > + > + bytes = valid_up - vbo; > + if (bytes < sb->s_blocksize) > + bytes = sb->s_blocksize; > + } > + > + if (bh->b_size > bytes) > + bh->b_size = bytes; > + > +#ifndef __LP64__ > + if (ctx == GET_BLOCK_DIRECT_IO_W || ctx == GET_BLOCK_DIRECT_IO_R) { > + static_assert(sizeof(size_t) < sizeof(loff_t)); > + if (bytes > 0x40000000u) > + bh->b_size = 0x40000000u; > + } > +#endif > + > + return 0; > + > +out: > + return err; > +} > + > +/*ntfs_readpage*/ > +/*ntfs_readpages*/ > +/*ntfs_writepage*/ > +/*ntfs_writepages*/ > +/*ntfs_block_truncate_page*/ > +int ntfs_get_block(struct inode *inode, sector_t vbn, > + struct buffer_head *bh_result, int create) > +{ > + return ntfs_get_block_vbo(inode, (u64)vbn << inode->i_blkbits, > + bh_result, create, GET_BLOCK_GENERAL); > +} > + > +/*ntfs_bmap*/ > +static int ntfs_get_block_bmap(struct inode *inode, sector_t vsn, > + struct buffer_head *bh_result, int create) > +{ > + return ntfs_get_block_vbo(inode, > + (u64)vsn << inode->i_sb->s_blocksize_bits, > + bh_result, create, GET_BLOCK_BMAP); > +} > + > +static sector_t ntfs_bmap(struct address_space *mapping, sector_t block) > +{ > + return generic_block_bmap(mapping, block, ntfs_get_block_bmap); > +} > + > +int ntfs_readpage(struct file *file, struct page *page) > +{ > + int err; > + struct address_space *mapping = page->mapping; > + struct inode *inode = mapping->host; > + struct ntfs_inode *ni = ntfs_i(inode); > + u64 vbo = (u64)page->index << PAGE_SHIFT; > + u64 valid; > + struct ATTRIB *attr; > + const char *data; > + u32 data_size; > + > + if (ni_has_resident_data(ni)) { > + ni_lock(ni); > + > + if (!ni_has_resident_data(ni)) { > + ni_unlock(ni); > + } else { > + attr = ni_find_attr(ni, NULL, NULL, ATTR_DATA, NULL, 0, > + NULL, NULL); > + if (!attr) { > + err = -EINVAL; > + ni_unlock(ni); > + unlock_page(page); > + goto out; > + } > + > + WARN_ON(attr->non_res); > + > + vbo = page->index << PAGE_SHIFT; > + data = resident_data(attr); > + data_size = le32_to_cpu(attr->res.data_size); > + > + if (vbo < data_size) { > + void *kaddr = kmap_atomic(page); > + > + err = data_size - vbo; > + if (err > PAGE_SIZE) > + err = PAGE_SIZE; > + > + memcpy(kaddr, data + vbo, err); > + flush_dcache_page(page); > + kunmap_atomic(kaddr); > + zero_user_segment(page, err, PAGE_SIZE); > + SetPageUptodate(page); > + } else if (!PageUptodate(page)) { > + zero_user_segment(page, 0, PAGE_SIZE); > + SetPageUptodate(page); > + } > + > + ni_unlock(ni); > + unlock_page(page); > + return 0; > + } > + } > + > + if (is_compressed(ni)) { > + ni_lock(ni); > + err = ni_readpage_cmpr(ni, page); > + ni_unlock(ni); > + return err; > + } > + > + /* normal + sparse files */ > + err = mpage_readpage(page, ntfs_get_block); > + if (err) > + goto out; > + > + valid = ni->i_valid; > + if (vbo < valid && valid < vbo + PAGE_SIZE) { > + if (PageLocked(page)) > + wait_on_page_bit(page, PG_locked); > + if (PageError(page)) { > + ntfs_inode_warn(inode, "file garbage at 0x%llx", valid); > + goto out; > + } > + zero_user_segment(page, valid & (PAGE_SIZE - 1), PAGE_SIZE); > + } > + > +out: > + return err; > +} > + > +static void ntfs_readahead(struct readahead_control *rac) > +{ > + struct address_space *mapping = rac->mapping; > + struct inode *inode = mapping->host; > + struct ntfs_inode *ni = ntfs_i(inode); > + u64 valid; > + loff_t pos; > + > + if (ni_has_resident_data(ni)) > + return; > + > + WARN_ON(is_compressed(ni)); > + > + valid = ni->i_valid; > + pos = readahead_pos(rac); > + > + if (pos <= valid && valid < pos + readahead_length(rac)) > + return; > + > + mpage_readahead(rac, ntfs_get_block); > +} > + > +/*ntfs_direct_IO*/ > +static int ntfs_get_block_direct_IO_R(struct inode *inode, sector_t iblock, > + struct buffer_head *bh_result, int create) > +{ > + return ntfs_get_block_vbo(inode, (u64)iblock << inode->i_blkbits, > + bh_result, create, GET_BLOCK_DIRECT_IO_R); > +} > + > +static int ntfs_get_block_direct_IO_W(struct inode *inode, sector_t iblock, > + struct buffer_head *bh_result, int create) > +{ > + return ntfs_get_block_vbo(inode, (u64)iblock << inode->i_blkbits, > + bh_result, create, GET_BLOCK_DIRECT_IO_W); > +} > + > +static void ntfs_write_failed(struct address_space *mapping, loff_t to) > +{ > + struct inode *inode = mapping->host; > + > + if (to > inode->i_size) { > + truncate_pagecache(inode, inode->i_size); > + ntfs_truncate_blocks(inode, inode->i_size); > + } > +} > + > +static ssize_t ntfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) > +{ > + struct file *file = iocb->ki_filp; > + struct address_space *mapping = file->f_mapping; > + struct inode *inode = mapping->host; > + struct ntfs_inode *ni = ntfs_i(inode); > + size_t count = iov_iter_count(iter); > + loff_t vbo = iocb->ki_pos; > + loff_t end = vbo + count; > + int wr = iov_iter_rw(iter) & WRITE; > + const struct iovec *iov = iter->iov; > + unsigned long nr_segs = iter->nr_segs; > + loff_t valid; > + ssize_t ret; > + > + ret = blockdev_direct_IO(iocb, inode, iter, > + wr ? ntfs_get_block_direct_IO_W : > + ntfs_get_block_direct_IO_R); > + valid = ni->i_valid; > + if (wr) { > + if (ret < 0) > + ntfs_write_failed(mapping, end); > + if (ret <= 0) > + goto out; > + > + vbo += ret; > + if (vbo > valid && !S_ISBLK(inode->i_mode)) { > + ni->i_valid = vbo; > + mark_inode_dirty(inode); > + } > + } else if (vbo < valid && valid < end) { > + /* fix page */ > + unsigned long uaddr = ~0ul; > + struct page *page; > + long i, npages; > + size_t dvbo = valid - vbo; > + size_t off = 0; > + > + /*Find user address*/ > + for (i = 0; i < nr_segs; i++) { > + if (off <= dvbo && dvbo < off + iov[i].iov_len) { > + uaddr = (unsigned long)iov[i].iov_base + dvbo - > + off; > + break; > + } > + off += iov[i].iov_len; > + } > + > + if (uaddr == ~0ul) > + goto fix_error; > + > + npages = get_user_pages_unlocked(uaddr, 1, &page, FOLL_WRITE); > + > + if (npages <= 0) > + goto fix_error; > + > + zero_user_segment(page, valid & (PAGE_SIZE - 1), PAGE_SIZE); > + put_page(page); > + } > + > +out: > + return ret; > +fix_error: > + ntfs_inode_warn(inode, "file garbage at 0x%llx", valid); > + goto out; > +} > + > +int ntfs_set_size(struct inode *inode, u64 new_size) > +{ > + struct super_block *sb = inode->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct ntfs_inode *ni = ntfs_i(inode); > + int err; > + > + /* Check for maximum file size */ > + if (is_sparsed(ni) || is_compressed(ni)) { > + if (new_size > sbi->maxbytes_sparse) { > + err = -EFBIG; > + goto out; > + } > + } else if (new_size > sbi->maxbytes) { > + err = -EFBIG; > + goto out; > + } > + > + ni_lock(ni); > + down_write(&ni->file.run_lock); > + > + err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size, > + &ni->i_valid, true, NULL); > + > + up_write(&ni->file.run_lock); > + ni_unlock(ni); > + > + mark_inode_dirty(inode); > + > +out: > + return err; > +} > + > +static int ntfs_writepage(struct page *page, struct writeback_control *wbc) > +{ > + return block_write_full_page(page, ntfs_get_block, wbc); > +} > + > +static int ntfs_writepage_cmpr(struct page *page, struct writeback_control *wbc) > +{ > + int err; > + struct address_space *mapping = page->mapping; > + struct inode *inode = mapping->host; > + struct ntfs_inode *ni = ntfs_i(inode); > + int sync = wbc->sync_mode == WB_SYNC_ALL; > + > + if (current->flags & PF_MEMALLOC) { > +redirty: > + redirty_page_for_writepage(wbc, page); > + unlock_page(page); > + return 0; > + } > + > + if (sync) > + ni_lock(ni); > + else if (!ni_trylock(ni)) > + goto redirty; > + > + err = ni_writepage_cmpr(page, sync); > + ni_unlock(ni); > + > + return err; > +} > + > +static int ntfs_writepages(struct address_space *mapping, > + struct writeback_control *wbc) > +{ > + return mpage_writepages(mapping, wbc, ntfs_get_block); > +} > + > +/*ntfs_write_begin*/ > +static int ntfs_get_block_write_begin(struct inode *inode, sector_t vbn, > + struct buffer_head *bh_result, int create) > +{ > + return ntfs_get_block_vbo(inode, (u64)vbn << inode->i_blkbits, > + bh_result, create, GET_BLOCK_WRITE_BEGIN); > +} > + > +static int ntfs_write_begin(struct file *file, struct address_space *mapping, > + loff_t pos, u32 len, u32 flags, struct page **pagep, > + void **fsdata) > +{ > + int err; > + > + *pagep = NULL; > + > + err = block_write_begin(mapping, pos, len, flags, pagep, > + ntfs_get_block_write_begin); > + if (err < 0) > + ntfs_write_failed(mapping, pos + len); > + > + return err; > +} > + > +/* address_space_operations::write_end */ > +static int ntfs_write_end(struct file *file, struct address_space *mapping, > + loff_t pos, u32 len, u32 copied, struct page *page, > + void *fsdata) > + > +{ > + struct inode *inode = mapping->host; > + struct ntfs_inode *ni = ntfs_i(inode); > + u64 valid = ni->i_valid; > + int err; > + > + err = generic_write_end(file, mapping, pos, len, copied, page, fsdata); > + > + if (err < len) > + ntfs_write_failed(mapping, pos + len); > + if (err >= 0) { > + bool dirty = false; > + > + if (!(ni->std_fa & FILE_ATTRIBUTE_ARCHIVE)) { > + inode->i_ctime = inode->i_mtime = current_time(inode); > + ni->std_fa |= FILE_ATTRIBUTE_ARCHIVE; > + dirty = true; > + } > + > + if (valid != ni->i_valid) { > + /* ni->i_valid is changed in ntfs_get_block_vbo */ > + dirty = true; > + } > + > + if (dirty) > + mark_inode_dirty(inode); > + } > + > + return err; > +} > + > +int reset_log_file(struct inode *inode) > +{ > + int err; > + loff_t pos = 0; > + u32 log_size = inode->i_size; > + struct address_space *mapping = inode->i_mapping; > + > + for (;;) { > + u32 len; > + void *kaddr; > + struct page *page; > + > + len = pos + PAGE_SIZE > log_size ? (log_size - pos) : PAGE_SIZE; > + > + err = block_write_begin(mapping, pos, len, 0, &page, > + ntfs_get_block_write_begin); > + if (err) > + goto out; > + > + kaddr = kmap_atomic(page); > + memset(kaddr, -1, len); > + kunmap_atomic(kaddr); > + flush_dcache_page(page); > + > + err = block_write_end(NULL, mapping, pos, len, len, page, NULL); > + if (err < 0) > + goto out; > + pos += len; > + > + if (pos >= log_size) > + break; > + balance_dirty_pages_ratelimited(mapping); > + } > +out: > + mark_inode_dirty_sync(inode); > + > + return err; > +} > + > +int ntfs_write_inode(struct inode *inode, struct writeback_control *wbc) > +{ > + if (WARN_ON_ONCE(current->flags & PF_MEMALLOC) || > + sb_rdonly(inode->i_sb)) > + return 0; > + > + return _ni_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL); > +} > + > +int ntfs_sync_inode(struct inode *inode) > +{ > + return _ni_write_inode(inode, 1); > +} > + > +/* > + * helper function for ntfs_flush_inodes. This writes both the inode > + * and the file data blocks, waiting for in flight data blocks before > + * the start of the call. It does not wait for any io started > + * during the call > + */ > +static int writeback_inode(struct inode *inode) > +{ > + int ret = sync_inode_metadata(inode, 0); > + > + if (!ret) > + ret = filemap_fdatawrite(inode->i_mapping); > + return ret; > +} > + > +/* > + * write data and metadata corresponding to i1 and i2. The io is > + * started but we do not wait for any of it to finish. > + * > + * filemap_flush is used for the block device, so if there is a dirty > + * page for a block already in flight, we will not wait and start the > + * io over again > + */ > +int ntfs_flush_inodes(struct super_block *sb, struct inode *i1, > + struct inode *i2) > +{ > + int ret = 0; > + > + if (i1) > + ret = writeback_inode(i1); > + if (!ret && i2) > + ret = writeback_inode(i2); > + if (!ret) > + ret = filemap_flush(sb->s_bdev->bd_inode->i_mapping); > + return ret; > +} > + > +int inode_write_data(struct inode *inode, const void *data, size_t bytes) > +{ > + pgoff_t idx; > + > + /* Write non resident data */ > + for (idx = 0; bytes; idx++) { > + size_t op = bytes > PAGE_SIZE ? PAGE_SIZE : bytes; > + struct page *page = ntfs_map_page(inode->i_mapping, idx); > + > + if (IS_ERR(page)) > + return PTR_ERR(page); > + > + lock_page(page); > + WARN_ON(!PageUptodate(page)); > + ClearPageUptodate(page); > + > + memcpy(page_address(page), data, op); > + > + flush_dcache_page(page); > + SetPageUptodate(page); > + unlock_page(page); > + > + ntfs_unmap_page(page); > + > + bytes -= op; > + data = Add2Ptr(data, PAGE_SIZE); > + } > + return 0; > +} > + > +int ntfs_create_inode(struct inode *dir, struct dentry *dentry, > + const struct cpu_str *uni, struct file *file, > + umode_t mode, dev_t dev, const char *symname, > + unsigned int size, int excl, struct ntfs_fnd *fnd, > + struct inode **new_inode) > +{ > + int err; > + struct super_block *sb = dir->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + const struct qstr *name = &dentry->d_name; > + CLST ino = 0; > + struct ntfs_inode *dir_ni = ntfs_i(dir); > + struct ntfs_inode *ni = NULL; > + struct inode *inode = NULL; > + struct ATTRIB *attr; > + struct ATTR_STD_INFO5 *std5; > + struct ATTR_FILE_NAME *fname; > + struct MFT_REC *rec; > + u32 asize, dsize, sd_size; > + enum FILE_ATTRIBUTE fa; > + __le32 security_id = SECURITY_ID_INVALID; > + CLST vcn; > + const void *sd; > + u16 t16, nsize = 0, aid = 0; > + struct INDEX_ROOT *root, *dir_root; > + struct NTFS_DE *e, *new_de = NULL; > + struct REPARSE_DATA_BUFFER *rp = NULL; > + typeof(rp->SymbolicLink2ReparseBuffer) *rb; > + __le16 *rp_name; > + bool is_dir = S_ISDIR(mode); > + bool rp_inserted = false; > + bool is_sp = S_ISCHR(mode) || S_ISBLK(mode) || S_ISFIFO(mode) || > + S_ISSOCK(mode); > + > + if (is_sp) > + return -EOPNOTSUPP; > + > + dir_root = indx_get_root(&dir_ni->dir, dir_ni, NULL, NULL); > + if (!dir_root) > + return -EINVAL; > + > + fa = (is_dir ? (dir_ni->std_fa | FILE_ATTRIBUTE_DIRECTORY) : > + S_ISLNK(mode) ? > + FILE_ATTRIBUTE_REPARSE_POINT : > + sbi->options.sparse ? > + FILE_ATTRIBUTE_SPARSE_FILE : > + (dir_ni->std_fa & FILE_ATTRIBUTE_COMPRESSED) ? > + FILE_ATTRIBUTE_COMPRESSED : > + 0) | > + FILE_ATTRIBUTE_ARCHIVE; > + > + if (!(mode & 0222)) { > + mode &= ~0222; > + fa |= FILE_ATTRIBUTE_READONLY; > + } > + > + new_de = __getname(); > + if (!new_de) { > + err = -ENOMEM; > + goto out1; > + } > + > + /*mark rw ntfs as dirty. it will be cleared at umount*/ > + ntfs_set_state(sbi, NTFS_DIRTY_DIRTY); > + > + /* Step 1: allocate and fill new mft record */ > + err = ntfs_look_free_mft(sbi, &ino, false, NULL, NULL); > + if (err) > + goto out2; > + > + ni = ntfs_new_inode(sbi, ino, is_dir); > + if (IS_ERR(ni)) { > + err = PTR_ERR(ni); > + ni = NULL; > + goto out3; > + } > + inode = &ni->vfs_inode; > + > + inode->i_atime = inode->i_mtime = inode->i_ctime = ni->i_crtime = > + current_time(inode); > + > + rec = ni->mi.mrec; > + rec->hard_links = cpu_to_le16(1); > + attr = Add2Ptr(rec, le16_to_cpu(rec->attr_off)); > + > + /* Get default security id */ > + sd = s_default_security; > + sd_size = sizeof(s_default_security); > + > + if (is_ntfs3(sbi)) { > + security_id = dir_ni->std_security_id; > + if (le32_to_cpu(security_id) < SECURITY_ID_FIRST) { > + security_id = sbi->security.def_security_id; > + > + if (security_id == SECURITY_ID_INVALID && > + !ntfs_insert_security(sbi, sd, sd_size, > + &security_id, NULL)) > + sbi->security.def_security_id = security_id; > + } > + } > + > + /* Insert standard info */ > + std5 = Add2Ptr(attr, SIZEOF_RESIDENT); > + > + if (security_id == SECURITY_ID_INVALID) { > + dsize = sizeof(struct ATTR_STD_INFO); > + } else { > + dsize = sizeof(struct ATTR_STD_INFO5); > + std5->security_id = security_id; > + ni->std_security_id = security_id; > + } > + asize = SIZEOF_RESIDENT + dsize; > + > + attr->type = ATTR_STD; > + attr->size = cpu_to_le32(asize); > + attr->id = cpu_to_le16(aid++); > + attr->res.data_off = SIZEOF_RESIDENT_LE; > + attr->res.data_size = cpu_to_le32(dsize); > + > + std5->cr_time = std5->m_time = std5->c_time = std5->a_time = > + kernel2nt(&inode->i_atime); > + > + ni->std_fa = fa; > + std5->fa = fa; > + > + attr = Add2Ptr(attr, asize); > + > + /* Insert file name */ > + err = fill_name_de(sbi, new_de, name, uni); > + if (err) > + goto out4; > + > + fname = (struct ATTR_FILE_NAME *)(new_de + 1); > + > + new_de->ref.low = cpu_to_le32(ino); > +#ifdef NTFS3_64BIT_CLUSTER > + new_de->ref.high = cpu_to_le16(ino >> 32); > + fname->home.high = cpu_to_le16(dir->i_ino >> 32); > +#endif > + new_de->ref.seq = rec->seq; > + > + fname->home.low = cpu_to_le32(dir->i_ino & 0xffffffff); > + fname->home.seq = dir_ni->mi.mrec->seq; > + > + fname->dup.cr_time = fname->dup.m_time = fname->dup.c_time = > + fname->dup.a_time = std5->cr_time; > + fname->dup.alloc_size = fname->dup.data_size = 0; > + fname->dup.fa = std5->fa; > + fname->dup.ea_size = fname->dup.reparse = 0; > + > + dsize = le16_to_cpu(new_de->key_size); > + asize = QuadAlign(SIZEOF_RESIDENT + dsize); > + > + attr->type = ATTR_NAME; > + attr->size = cpu_to_le32(asize); > + attr->res.data_off = SIZEOF_RESIDENT_LE; > + attr->res.flags = RESIDENT_FLAG_INDEXED; > + attr->id = cpu_to_le16(aid++); > + attr->res.data_size = cpu_to_le32(dsize); > + memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), fname, dsize); > + > + attr = Add2Ptr(attr, asize); > + > + if (security_id == SECURITY_ID_INVALID) { > + /* Insert security attribute */ > + asize = SIZEOF_RESIDENT + QuadAlign(sd_size); > + > + attr->type = ATTR_SECURE; > + attr->size = cpu_to_le32(asize); > + attr->id = cpu_to_le16(aid++); > + attr->res.data_off = SIZEOF_RESIDENT_LE; > + attr->res.data_size = cpu_to_le32(sd_size); > + memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), sd, sd_size); > + > + attr = Add2Ptr(attr, asize); > + } > + > + if (is_dir) { > + /* Create root of directory */ > + dsize = sizeof(struct INDEX_ROOT) + sizeof(struct NTFS_DE); > + asize = sizeof(I30_NAME) + SIZEOF_RESIDENT + dsize; > + > + attr->type = ATTR_ROOT; > + attr->size = cpu_to_le32(asize); > + attr->id = cpu_to_le16(aid++); > + > + attr->name_len = ARRAY_SIZE(I30_NAME); > + attr->name_off = SIZEOF_RESIDENT_LE; > + attr->res.data_off = > + cpu_to_le16(sizeof(I30_NAME) + SIZEOF_RESIDENT); > + attr->res.data_size = cpu_to_le32(dsize); > + memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), I30_NAME, > + sizeof(I30_NAME)); > + > + root = Add2Ptr(attr, sizeof(I30_NAME) + SIZEOF_RESIDENT); > + memcpy(root, dir_root, offsetof(struct INDEX_ROOT, ihdr)); > + root->ihdr.de_off = > + cpu_to_le32(sizeof(struct INDEX_HDR)); // 0x10 > + root->ihdr.used = cpu_to_le32(sizeof(struct INDEX_HDR) + > + sizeof(struct NTFS_DE)); > + root->ihdr.total = root->ihdr.used; > + > + e = Add2Ptr(root, sizeof(struct INDEX_ROOT)); > + e->size = cpu_to_le16(sizeof(struct NTFS_DE)); > + e->flags = NTFS_IE_LAST; > + > + ni->ni_flags |= NI_FLAG_DIR; > + > + err = indx_init(&ni->dir, sbi, attr, INDEX_MUTEX_I30); > + if (err) > + goto out4; > + } else if (S_ISLNK(mode)) { > + /* Create symlink */ > + dsize = 0; > + asize = SIZEOF_RESIDENT; > + > + /* insert empty ATTR_DATA */ > + attr->type = ATTR_DATA; > + attr->size = cpu_to_le32(SIZEOF_RESIDENT); > + attr->id = cpu_to_le16(aid++); > + attr->name_off = SIZEOF_RESIDENT_LE; > + attr->res.data_off = SIZEOF_RESIDENT_LE; > + > + attr = Add2Ptr(attr, asize); > + > + /* > + * Insert ATTR_REPARSE > + * Assume each symbol is coded at most with 2 utf16 and zero > + */ > + rp = ntfs_alloc(ntfs_reparse_bytes(2 * size + 2), 1); > + if (!rp) { > + err = -ENOMEM; > + goto out4; > + } > + rb = &rp->SymbolicLink2ReparseBuffer; > + rp_name = rb->PathBuffer; > + > + /* Convert link name to utf16 */ > + err = ntfs_nls_to_utf16(sbi, symname, size, > + (struct cpu_str *)(rp_name - 1), > + 2 * size, UTF16_LITTLE_ENDIAN); > + if (err < 0) > + goto out4; > + > + /* err = the length of unicode name of symlink */ > + nsize = ntfs_reparse_bytes(err); > + > + if (nsize > sbi->reparse.max_size) { > + err = -EFBIG; > + goto out4; > + } > + > + rp->ReparseTag = IO_REPARSE_TAG_SYMLINK; > + rp->ReparseDataLength = cpu_to_le16( > + (nsize - offsetof(struct REPARSE_DATA_BUFFER, > + SymbolicLink2ReparseBuffer))); > + rb = &rp->SymbolicLink2ReparseBuffer; > + rb->SubstituteNameOffset = cpu_to_le16(sizeof(short) * err); > + rb->SubstituteNameLength = cpu_to_le16(sizeof(short) * err + 8); > + rb->PrintNameLength = rb->SubstituteNameOffset; > + rb->Flags = 0; > + > + memmove(rp_name + err + 4, rp_name, sizeof(short) * err); > + > + rp_name += err; > + rp_name[0] = cpu_to_le16('\\'); > + rp_name[1] = cpu_to_le16('?'); > + rp_name[2] = cpu_to_le16('?'); > + rp_name[3] = cpu_to_le16('\\'); > + > + attr->type = ATTR_REPARSE; > + attr->id = cpu_to_le16(aid++); > + > + /* resident or non resident? */ > + asize = QuadAlign(SIZEOF_RESIDENT + nsize); > + t16 = PtrOffset(rec, attr); > + > + if (asize + t16 + 8 > sbi->record_size) { > + CLST alen; > + CLST clst = bytes_to_cluster(sbi, nsize); > + > + /* bytes per runs */ > + t16 = sbi->record_size - t16 - SIZEOF_NONRESIDENT; > + > + attr->non_res = 1; > + attr->nres.evcn = cpu_to_le64(clst - 1); > + attr->name_off = SIZEOF_NONRESIDENT_LE; > + attr->nres.run_off = attr->name_off; > + attr->nres.data_size = cpu_to_le64(nsize); > + attr->nres.valid_size = attr->nres.data_size; > + attr->nres.alloc_size = > + cpu_to_le64(ntfs_up_cluster(sbi, nsize)); > + > + err = attr_allocate_clusters(sbi, &ni->file.run, 0, 0, > + clst, NULL, 0, &alen, 0, > + NULL); > + if (err) > + goto out5; > + > + err = run_pack(&ni->file.run, 0, clst, > + Add2Ptr(attr, SIZEOF_NONRESIDENT), t16, > + &vcn); > + if (err < 0) > + goto out5; > + > + if (vcn != clst) { > + err = -EINVAL; > + goto out5; > + } > + > + asize = SIZEOF_NONRESIDENT + QuadAlign(err); > + inode->i_size = nsize; > + } else { > + attr->res.data_off = SIZEOF_RESIDENT_LE; > + attr->res.data_size = cpu_to_le32(nsize); > + memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), rp, nsize); > + inode->i_size = nsize; > + nsize = 0; > + } > + > + attr->size = cpu_to_le32(asize); > + > + err = ntfs_insert_reparse(sbi, IO_REPARSE_TAG_SYMLINK, > + &new_de->ref); > + if (err) > + goto out5; > + > + rp_inserted = true; > + } else { > + attr->type = ATTR_DATA; > + attr->id = cpu_to_le16(aid++); > + /* Create non resident data attribute */ > + attr->non_res = 1; > + attr->nres.evcn = cpu_to_le64(-1ll); > + if (fa & FILE_ATTRIBUTE_SPARSE_FILE) { > + attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8); > + attr->name_off = SIZEOF_NONRESIDENT_EX_LE; > + attr->flags = ATTR_FLAG_SPARSED; > + asize = SIZEOF_NONRESIDENT_EX + 8; > + } else if (fa & FILE_ATTRIBUTE_COMPRESSED) { > + attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8); > + attr->name_off = SIZEOF_NONRESIDENT_EX_LE; > + attr->flags = ATTR_FLAG_COMPRESSED; > + attr->nres.c_unit = COMPRESSION_UNIT; > + asize = SIZEOF_NONRESIDENT_EX + 8; > + } else { > + attr->size = cpu_to_le32(SIZEOF_NONRESIDENT + 8); > + attr->name_off = SIZEOF_NONRESIDENT_LE; > + asize = SIZEOF_NONRESIDENT + 8; > + } > + attr->nres.run_off = attr->name_off; > + } > + > + attr = Add2Ptr(attr, asize); > + attr->type = ATTR_END; > + > + rec->used = cpu_to_le32(PtrOffset(rec, attr) + 8); > + rec->next_attr_id = cpu_to_le16(aid); > + > + /* Step 2: Add new name in index */ > + err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, fnd); > + if (err) > + goto out6; > + > + /* Update current directory record */ > + mark_inode_dirty(dir); > + > + /* Fill vfs inode fields */ > + inode->i_uid = sbi->options.uid ? sbi->options.fs_uid : current_fsuid(); > + inode->i_gid = > + sbi->options.gid ? > + sbi->options.fs_gid : > + (dir->i_mode & S_ISGID) ? dir->i_gid : current_fsgid(); > + inode->i_generation = le16_to_cpu(rec->seq); > + > + dir->i_mtime = dir->i_ctime = inode->i_atime; > + > + if (is_dir) { > + if (dir->i_mode & S_ISGID) > + mode |= S_ISGID; > + inode->i_op = &ntfs_dir_inode_operations; > + inode->i_fop = &ntfs_dir_operations; > + } else if (S_ISLNK(mode)) { > + inode->i_op = &ntfs_link_inode_operations; > + inode->i_fop = NULL; > + inode->i_mapping->a_ops = &ntfs_aops; > + } else { > + inode->i_op = &ntfs_file_inode_operations; > + inode->i_fop = &ntfs_file_operations; > + inode->i_mapping->a_ops = > + is_compressed(ni) ? &ntfs_aops_cmpr : &ntfs_aops; > + init_rwsem(&ni->file.run_lock); > + } > + > + inode->i_mode = mode; > + > + if (!S_ISLNK(mode) && (sb->s_flags & SB_POSIXACL)) { > + err = ntfs_init_acl(inode, dir); > + if (err) > + goto out6; > + } > + > + /* call 'd_instantiate' after inode->i_op is set */ > + d_instantiate(dentry, inode); > + > + /* Write non resident data */ > + if (nsize) { > + err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rp, nsize); > + if (err) > + goto out7; > + } > + > +#ifdef NTFS_COUNT_CONTAINED > + if (S_ISDIR(mode)) > + inc_nlink(dir); > +#endif > + if (file) { > + if (is_dir) > + err = finish_no_open(file, NULL); > + else > + err = finish_open(file, dentry, ntfs_file_open); > + > + if (err) > + goto out7; > + file->f_mode |= FMODE_CREATED; > + } > + > + /* normal exit */ > + mark_inode_dirty(inode); > + mark_inode_dirty(dir); > + goto out2; > + > +out7: > + > + /* undo 'indx_insert_entry' */ > + indx_delete_entry(&dir_ni->dir, dir_ni, new_de + 1, > + le16_to_cpu(new_de->key_size), sbi); > +out6: > + if (rp_inserted) > + ntfs_remove_reparse(sbi, IO_REPARSE_TAG_SYMLINK, &new_de->ref); > + > +out5: > + if (is_dir || run_is_empty(&ni->file.run)) > + goto out4; > + > + run_deallocate(sbi, &ni->file.run, false); > + > +out4: > + clear_rec_inuse(rec); > + clear_nlink(inode); > + ni->mi.dirty = false; > + discard_new_inode(inode); > +out3: > + ntfs_mark_rec_free(sbi, ino); > + > +out2: > + __putname(new_de); > + ntfs_free(rp); > + > +out1: > + if (err) > + return err; > + > + unlock_new_inode(inode); > + > + *new_inode = inode; > + return 0; > +} > + > +int ntfs_link_inode(struct inode *inode, struct dentry *dentry) > +{ > + int err; > + struct inode *dir = d_inode(dentry->d_parent); > + struct ntfs_inode *dir_ni = ntfs_i(dir); > + struct ntfs_inode *ni = ntfs_i(inode); > + struct super_block *sb = inode->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + const struct qstr *name = &dentry->d_name; > + struct NTFS_DE *new_de = NULL; > + struct ATTR_FILE_NAME *fname; > + struct ATTRIB *attr; > + u16 key_size; > + struct INDEX_ROOT *dir_root; > + > + dir_root = indx_get_root(&dir_ni->dir, dir_ni, NULL, NULL); > + if (!dir_root) > + return -EINVAL; > + > + new_de = __getname(); > + if (!new_de) > + return -ENOMEM; > + > + /*mark rw ntfs as dirty. it will be cleared at umount*/ > + ntfs_set_state(ni->mi.sbi, NTFS_DIRTY_DIRTY); > + > + // Insert file name > + err = fill_name_de(sbi, new_de, name, NULL); > + if (err) > + goto out; > + > + key_size = le16_to_cpu(new_de->key_size); > + fname = (struct ATTR_FILE_NAME *)(new_de + 1); > + > + err = ni_insert_resident(ni, key_size, ATTR_NAME, NULL, 0, &attr, NULL); > + if (err) > + goto out; > + > + new_de->ref.low = cpu_to_le32(inode->i_ino); > +#ifdef NTFS3_64BIT_CLUSTER > + new_de->ref.high = cpu_to_le16(inode->i_ino >> 32); > + fname->home.high = cpu_to_le16(dir->i_ino >> 32); > +#endif > + new_de->ref.seq = ni->mi.mrec->seq; > + > + fname->home.low = cpu_to_le32(dir->i_ino & 0xffffffff); > + fname->home.seq = dir_ni->mi.mrec->seq; > + > + fname->dup.cr_time = fname->dup.m_time = fname->dup.c_time = > + fname->dup.a_time = kernel2nt(&inode->i_ctime); > + fname->dup.alloc_size = fname->dup.data_size = 0; > + fname->dup.fa = ni->std_fa; > + fname->dup.ea_size = fname->dup.reparse = 0; > + > + memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), fname, key_size); > + > + err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, NULL); > + if (err) > + goto out; > + > + le16_add_cpu(&ni->mi.mrec->hard_links, 1); > + ni->mi.dirty = true; > + > +out: > + __putname(new_de); > + return err; > +} > + > +/* > + * ntfs_unlink_inode > + * > + * inode_operations::unlink > + * inode_operations::rmdir > + */ > +int ntfs_unlink_inode(struct inode *dir, const struct dentry *dentry) > +{ > + int err; > + struct super_block *sb = dir->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct inode *inode = d_inode(dentry); > + struct ntfs_inode *ni = ntfs_i(inode); > + const struct qstr *name = &dentry->d_name; > + struct ntfs_inode *dir_ni = ntfs_i(dir); > + struct ntfs_index *indx = &dir_ni->dir; > + struct cpu_str *uni = NULL; > + struct ATTR_FILE_NAME *fname; > + u8 name_type; > + struct ATTR_LIST_ENTRY *le; > + struct MFT_REF ref; > + bool is_dir = S_ISDIR(inode->i_mode); > + struct INDEX_ROOT *dir_root; > + > + dir_root = indx_get_root(indx, dir_ni, NULL, NULL); > + if (!dir_root) > + return -EINVAL; > + > + ni_lock(ni); > + > + if (is_dir && !dir_is_empty(inode)) { > + err = -ENOTEMPTY; > + goto out1; > + } > + > + if (ntfs_is_meta_file(sbi, inode->i_ino)) { > + err = -EINVAL; > + goto out1; > + } > + > + uni = __getname(); > + if (!uni) { > + err = -ENOMEM; > + goto out1; > + } > + > + /* Convert input string to unicode */ > + err = ntfs_nls_to_utf16(sbi, name->name, name->len, uni, NTFS_NAME_LEN, > + UTF16_HOST_ENDIAN); > + if (err < 0) > + goto out4; > + > + le = NULL; > + > + /*mark rw ntfs as dirty. it will be cleared at umount*/ > + ntfs_set_state(sbi, NTFS_DIRTY_DIRTY); > + > + /* find name in record */ > +#ifdef NTFS3_64BIT_CLUSTER > + ref.low = cpu_to_le32(dir->i_ino & 0xffffffff); > + ref.high = cpu_to_le16(dir->i_ino >> 32); > +#else > + ref.low = cpu_to_le32(dir->i_ino & 0xffffffff); > + ref.high = 0; > +#endif > + ref.seq = dir_ni->mi.mrec->seq; > + > + fname = ni_fname_name(ni, uni, &ref, &le); > + if (!fname) { > + err = -ENOENT; > + goto out3; > + } > + > + name_type = paired_name(fname->type); > + > + err = indx_delete_entry(indx, dir_ni, fname, fname_full_size(fname), > + sbi); > + if (err) > + goto out4; > + > + /* Then remove name from mft */ > + ni_remove_attr_le(ni, attr_from_name(fname), le); > + > + le16_add_cpu(&ni->mi.mrec->hard_links, -1); > + ni->mi.dirty = true; > + > + if (name_type != FILE_NAME_POSIX) { > + /* Now we should delete name by type */ > + fname = ni_fname_type(ni, name_type, &le); > + if (fname) { > + err = indx_delete_entry(indx, dir_ni, fname, > + fname_full_size(fname), sbi); > + if (err) > + goto out4; > + > + ni_remove_attr_le(ni, attr_from_name(fname), le); > + > + le16_add_cpu(&ni->mi.mrec->hard_links, -1); > + } > + } > + > +out4: > + switch (err) { > + case 0: > + drop_nlink(inode); > + case -ENOTEMPTY: > + case -ENOSPC: > + case -EROFS: > + break; > + default: > + make_bad_inode(inode); > + } > + > + dir->i_mtime = dir->i_ctime = current_time(dir); > + mark_inode_dirty(dir); > + inode->i_ctime = dir->i_ctime; > + if (inode->i_nlink) > + mark_inode_dirty(inode); > + > +#ifdef NTFS_COUNT_CONTAINED > + if (is_dir) { > + clear_nlink(inode); > + drop_nlink(dir); > + mark_inode_dirty(dir); > + } > +#endif > + > +out3: > + __putname(uni); > +out1: > + ni_unlock(ni); > + return err; > +} > + > +void ntfs_evict_inode(struct inode *inode) > +{ > + truncate_inode_pages_final(&inode->i_data); > + > + if (inode->i_nlink) > + _ni_write_inode(inode, inode_needs_sync(inode)); > + > + invalidate_inode_buffers(inode); > + clear_inode(inode); > + > + ni_clear(ntfs_i(inode)); > +} > + > +static noinline int ntfs_readlink_hlp(struct inode *inode, char *buffer, > + int buflen) > +{ > + int err = 0; > + struct ntfs_inode *ni = ntfs_i(inode); > + struct super_block *sb = inode->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + u64 i_size = inode->i_size; > + u16 nlen = 0; > + void *to_free = NULL; > + struct REPARSE_DATA_BUFFER *rp; > + struct le_str *uni; > + struct ATTRIB *attr; > + > + /* Reparse data present. Try to parse it */ > + static_assert(!offsetof(struct REPARSE_DATA_BUFFER, ReparseTag)); > + static_assert(sizeof(u32) == sizeof(rp->ReparseTag)); > + > + *buffer = 0; > + > + /* Read into temporal buffer */ > + if (i_size > sbi->reparse.max_size || i_size <= sizeof(u32)) { > + err = -EINVAL; > + goto out; > + } > + > + attr = ni_find_attr(ni, NULL, NULL, ATTR_REPARSE, NULL, 0, NULL, NULL); > + if (!attr) { > + err = -EINVAL; > + goto out; > + } > + > + if (!attr->non_res) { > + rp = resident_data_ex(attr, i_size); > + if (!rp) { > + err = -EINVAL; > + goto out; > + } > + } else { > + rp = ntfs_alloc(i_size, 0); > + if (!rp) { > + err = -ENOMEM; > + goto out; > + } > + to_free = rp; > + err = ntfs_read_run_nb(sbi, &ni->file.run, 0, rp, i_size, NULL); > + if (err) > + goto out; > + } > + > + err = -EINVAL; > + > + /* Microsoft Tag */ > + switch (rp->ReparseTag) { > + case IO_REPARSE_TAG_MICROSOFT | IO_REPARSE_TAG_SYMBOLIC_LINK: > + /* Symbolic link */ > + /* Can we use 'Rp->SymbolicLinkReparseBuffer.PrintNameLength'? */ > + if (i_size <= offsetof(struct REPARSE_DATA_BUFFER, > + SymbolicLinkReparseBuffer.PathBuffer)) > + goto out; > + uni = Add2Ptr(rp, > + offsetof(struct REPARSE_DATA_BUFFER, > + SymbolicLinkReparseBuffer.PathBuffer) + > + le16_to_cpu(rp->SymbolicLinkReparseBuffer > + .PrintNameOffset) - > + 2); > + nlen = le16_to_cpu( > + rp->SymbolicLinkReparseBuffer.PrintNameLength); > + break; > + > + case IO_REPARSE_TAG_MOUNT_POINT: > + /* Mount points and junctions */ > + /* Can we use 'Rp->MountPointReparseBuffer.PrintNameLength'? */ > + if (i_size <= offsetof(struct REPARSE_DATA_BUFFER, > + MountPointReparseBuffer.PathBuffer)) > + goto out; > + uni = Add2Ptr(rp, > + offsetof(struct REPARSE_DATA_BUFFER, > + MountPointReparseBuffer.PathBuffer) + > + le16_to_cpu(rp->MountPointReparseBuffer > + .PrintNameOffset) - > + 2); > + nlen = le16_to_cpu(rp->MountPointReparseBuffer.PrintNameLength); > + break; > + > + case IO_REPARSE_TAG_SYMLINK: > + /* FolderSymbolicLink */ > + /* Can we use 'Rp->SymbolicLink2ReparseBuffer.PrintNameLength'? */ > + if (i_size <= offsetof(struct REPARSE_DATA_BUFFER, > + SymbolicLink2ReparseBuffer.PathBuffer)) > + goto out; > + uni = Add2Ptr(rp, > + offsetof(struct REPARSE_DATA_BUFFER, > + SymbolicLink2ReparseBuffer.PathBuffer) + > + le16_to_cpu(rp->SymbolicLink2ReparseBuffer > + .PrintNameOffset) - > + 2); > + nlen = le16_to_cpu( > + rp->SymbolicLink2ReparseBuffer.PrintNameLength); > + break; > + > + case IO_REPARSE_TAG_CLOUD: > + case IO_REPARSE_TAG_CLOUD_1: > + case IO_REPARSE_TAG_CLOUD_2: > + case IO_REPARSE_TAG_CLOUD_3: > + case IO_REPARSE_TAG_CLOUD_4: > + case IO_REPARSE_TAG_CLOUD_5: > + case IO_REPARSE_TAG_CLOUD_6: > + case IO_REPARSE_TAG_CLOUD_7: > + case IO_REPARSE_TAG_CLOUD_8: > + case IO_REPARSE_TAG_CLOUD_9: > + case IO_REPARSE_TAG_CLOUD_A: > + case IO_REPARSE_TAG_CLOUD_B: > + case IO_REPARSE_TAG_CLOUD_C: > + case IO_REPARSE_TAG_CLOUD_D: > + case IO_REPARSE_TAG_CLOUD_E: > + case IO_REPARSE_TAG_CLOUD_F: > + err = sizeof("OneDrive") - 1; > + if (err > buflen) > + err = buflen; > + memcpy(buffer, "OneDrive", err); > + goto out; > + > + default: > + if (IsReparseTagMicrosoft(rp->ReparseTag)) > + goto out; > + if (!IsReparseTagNameSurrogate(rp->ReparseTag) || > + i_size <= sizeof(struct REPARSE_POINT)) { > + goto out; > + } > + > + /* Users tag */ > + uni = Add2Ptr(rp, sizeof(struct REPARSE_POINT) - 2); > + nlen = le16_to_cpu( > + ((struct REPARSE_POINT *)rp)->ReparseDataLength) - > + sizeof(struct REPARSE_POINT); > + } > + > + /* Convert nlen from bytes to UNICODE chars */ > + nlen >>= 1; > + > + /* Check that name is available */ > + if (!nlen || &uni->name[nlen] > (__le16 *)Add2Ptr(rp, i_size)) > + goto out; > + > + /* If name is already zero terminated then truncate it now */ > + if (!uni->name[nlen - 1]) > + nlen -= 1; > + uni->len = nlen; > + > + err = ntfs_utf16_to_nls(sbi, uni, buffer, buflen); > + > + if (err < 0) > + goto out; > + > + /* Always set last zero */ > + buffer[err] = 0; > + > +out: > + ntfs_free(to_free); > + > + return err; > +} > + > +static const char *ntfs_get_link(struct dentry *de, struct inode *inode, > + struct delayed_call *done) > +{ > + int err; > + char *ret; > + > + if (!de) > + return ERR_PTR(-ECHILD); > + > + ret = kmalloc(PAGE_SIZE, GFP_NOFS); > + if (!ret) > + return ERR_PTR(-ENOMEM); > + > + err = ntfs_readlink_hlp(inode, ret, PAGE_SIZE); > + if (err < 0) { > + kfree(ret); > + return ERR_PTR(err); > + } > + > + set_delayed_call(done, kfree_link, ret); > + > + return ret; > +} > + > +const struct inode_operations ntfs_link_inode_operations = { > + .get_link = ntfs_get_link, > + .setattr = ntfs_setattr, > + .listxattr = ntfs_listxattr, > + .permission = ntfs_permission, > + .get_acl = ntfs_get_acl, > + .set_acl = ntfs_set_acl, > +}; > + > +const struct address_space_operations ntfs_aops = { .readpage = ntfs_readpage, > + .readahead = ntfs_readahead, > + .writepage = ntfs_writepage, > + .writepages = > + ntfs_writepages, > + .write_begin = > + ntfs_write_begin, > + .write_end = ntfs_write_end, > + .direct_IO = ntfs_direct_IO, > + .bmap = ntfs_bmap }; > + > +const struct address_space_operations ntfs_aops_cmpr = { > + .readpage = ntfs_readpage, > + .writepage = ntfs_writepage_cmpr, > + .set_page_dirty = __set_page_dirty_nobuffers, > +}; > diff --git a/fs/ntfs3/super.c b/fs/ntfs3/super.c > new file mode 100644 > index 000000000000..14915398dd74 > --- /dev/null > +++ b/fs/ntfs3/super.c > @@ -0,0 +1,1430 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * linux/fs/ntfs3/super.c > + * > + * Copyright (C) 2019-2020 Paragon Software GmbH, All rights reserved. > + * > + * > + * terminology > + * > + * vcn - virtual cluster number - offset inside the file in clusters > + * vbo - virtual byte offset - offset inside the file in bytes > + * lcn - logical cluster number - 0 based cluster in clusters heap > + * lbo - logical byte offset - absolute position inside volume > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "debug.h" > +#include "ntfs.h" > +#include "ntfs_fs.h" > + > +#ifdef CONFIG_PRINTK > +/* > + * Trace warnings/notices/errors > + * Thanks Joe Perches for implementation > + */ > +void ntfs_printk(const struct super_block *sb, const char *fmt, ...) > +{ > + struct va_format vaf; > + va_list args; > + int level; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + > + /*should we use different ratelimits for warnings/notices/errors? */ > + if (!___ratelimit(&sbi->msg_ratelimit, "ntfs3")) > + return; > + > + va_start(args, fmt); > + > + level = printk_get_level(fmt); > + vaf.fmt = printk_skip_level(fmt); > + vaf.va = &args; > + printk("%c%cntfs3: %s: %pV\n", KERN_SOH_ASCII, level, sb->s_id, &vaf); > + > + va_end(args); > +} > + > +/* print warnings/notices/errors about inode using name or inode number */ > +void ntfs_inode_printk(struct inode *inode, const char *fmt, ...) > +{ > + struct super_block *sb = inode->i_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct dentry *dentry; > + char *name; > + va_list args; > + struct va_format vaf; > + int level; > + /*not necessary to print full inode name. just for information */ > + const u32 name_len = 63; > + > + if (!___ratelimit(&sbi->msg_ratelimit, "ntfs3")) > + return; > + > + name = ntfs_alloc(name_len + 1, 0); > + if (!name) > + return; > + > + dentry = d_find_alias(inode); > + if (dentry) { > + /*we can get the name of inode*/ > + spin_lock(&dentry->d_lock); > + snprintf(name, name_len, "%s", dentry->d_name.name); > + spin_unlock(&dentry->d_lock); > + dput(dentry); > + name[name_len] = 0; /* to be sure*/ > + } else { > + /*use inode number as inode info*/ > + snprintf(name, name_len, "ino=%lx", inode->i_ino); > + } > + > + va_start(args, fmt); > + > + level = printk_get_level(fmt); > + vaf.fmt = printk_skip_level(fmt); > + vaf.va = &args; > + > + printk("%c%cntfs3: %s: %s %pV\n", KERN_SOH_ASCII, level, sb->s_id, name, > + &vaf); > + > + va_end(args); > + > + ntfs_free(name); > +} > +#endif > + > +/* > + * Shared memory struct. > + * > + * on-disk ntfs's upcase table is created by ntfs formater > + * 'upcase' table is 128K bytes of memory > + * we should read it into memory when mounting > + * Several ntfs volumes likely use the same 'upcase' table > + * It is good idea to share in-memory 'upcase' table between different volumes > + * Unfortunately winxp/vista/win7 use different upcase tables > + */ > +static DEFINE_SPINLOCK(s_shared_lock); > + > +static struct { > + void *ptr; > + u32 len; > + int cnt; > +} s_shared[8]; > + > +/* > + * ntfs_set_shared > + * > + * Returns 'ptr' if pointer was saved in shared memory > + * Returns NULL if pointer was not shared > + */ > +void *ntfs_set_shared(void *ptr, u32 bytes) > +{ > + void *ret = NULL; > + int i, j = -1; > + > + spin_lock(&s_shared_lock); > + for (i = 0; i < ARRAY_SIZE(s_shared); i++) { > + if (!s_shared[i].cnt) { > + j = i; > + } else if (bytes == s_shared[i].len && > + !memcmp(s_shared[i].ptr, ptr, bytes)) { > + s_shared[i].cnt += 1; > + ret = s_shared[i].ptr; > + break; > + } > + } > + > + if (!ret && j != -1) { > + s_shared[j].ptr = ptr; > + s_shared[j].len = bytes; > + s_shared[j].cnt = 1; > + ret = ptr; > + } > + spin_unlock(&s_shared_lock); > + > + return ret; > +} > + > +/* > + * ntfs_put_shared > + * > + * Returns 'ptr' if pointer is not shared anymore > + * Returns NULL if pointer is still shared > + */ > +void *ntfs_put_shared(void *ptr) > +{ > + void *ret = ptr; > + int i; > + > + spin_lock(&s_shared_lock); > + for (i = 0; i < ARRAY_SIZE(s_shared); i++) { > + if (s_shared[i].cnt && s_shared[i].ptr == ptr) { > + if (--s_shared[i].cnt) > + ret = NULL; > + break; > + } > + } > + spin_unlock(&s_shared_lock); > + > + return ret; > +} > + > +static int ntfs_remount(struct super_block *sb, int *flags, char *data) > +{ > + *flags |= SB_NODIRATIME | SB_NOATIME; > + sync_filesystem(sb); > + return 0; > +} > + > +static struct kmem_cache *ntfs_inode_cachep; > + > +static struct inode *ntfs_alloc_inode(struct super_block *sb) > +{ > + struct ntfs_inode *ni = kmem_cache_alloc(ntfs_inode_cachep, GFP_NOFS); > + > + if (!ni) > + return NULL; > + > + memset(ni, 0, offsetof(struct ntfs_inode, vfs_inode)); > + > + mutex_init(&ni->ni_lock); > + > + return &ni->vfs_inode; > +} > + > +static void ntfs_i_callback(struct rcu_head *head) > +{ > + struct inode *inode = container_of(head, struct inode, i_rcu); > + struct ntfs_inode *ni = ntfs_i(inode); > + > + mutex_destroy(&ni->ni_lock); > + > + kmem_cache_free(ntfs_inode_cachep, ni); > +} > + > +static void ntfs_destroy_inode(struct inode *inode) > +{ > + call_rcu(&inode->i_rcu, ntfs_i_callback); > +} > + > +static void init_once(void *foo) > +{ > + struct ntfs_inode *ni = foo; > + > + inode_init_once(&ni->vfs_inode); > +} > + > +/* noinline to reduce binary size*/ > +static noinline void put_ntfs(struct ntfs_sb_info *sbi) > +{ > + ntfs_free(sbi->new_rec); > + ntfs_free(ntfs_put_shared(sbi->upcase)); > + ntfs_free(sbi->def_table); > + > + wnd_close(&sbi->mft.bitmap); > + wnd_close(&sbi->used.bitmap); > + > + if (sbi->mft.ni) > + iput(&sbi->mft.ni->vfs_inode); > + > + if (sbi->security.ni) > + iput(&sbi->security.ni->vfs_inode); > + > + if (sbi->reparse.ni) > + iput(&sbi->reparse.ni->vfs_inode); > + > + if (sbi->objid.ni) > + iput(&sbi->objid.ni->vfs_inode); > + > + if (sbi->volume.ni) > + iput(&sbi->volume.ni->vfs_inode); > + > + ntfs_update_mftmirr(sbi, 0); > + > + indx_clear(&sbi->security.index_sii); > + indx_clear(&sbi->security.index_sdh); > + indx_clear(&sbi->reparse.index_r); > + indx_clear(&sbi->objid.index_o); > + ntfs_free(sbi->compress.frame_unc); > + ntfs_free(sbi->compress.ctx); > + > + unload_nls(sbi->nls[0]); > + unload_nls(sbi->nls[1]); > + > + ntfs_free(sbi); > +} > + > +static void ntfs_put_super(struct super_block *sb) > +{ > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + > + /*mark rw ntfs as clear, if possible*/ > + ntfs_set_state(sbi, NTFS_DIRTY_CLEAR); > + > + put_ntfs(sbi); > + > + sync_blockdev(sb->s_bdev); > +} > + > +static int ntfs_statfs(struct dentry *dentry, struct kstatfs *buf) > +{ > + struct super_block *sb = dentry->d_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct wnd_bitmap *wnd = &sbi->used.bitmap; > + > + buf->f_type = sb->s_magic; > + buf->f_bsize = sbi->cluster_size; > + buf->f_blocks = wnd->nbits; > + > + buf->f_bfree = buf->f_bavail = wnd_zeroes(wnd); > + buf->f_fsid.val[0] = (u32)sbi->volume.ser_num; > + buf->f_fsid.val[1] = (u32)(sbi->volume.ser_num >> 32); > + buf->f_namelen = NTFS_NAME_LEN; > + > + return 0; > +} > + > +static int ntfs_show_options(struct seq_file *m, struct dentry *root) > +{ > + struct super_block *sb = root->d_sb; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct mount_options *opts = &sbi->options; > + > + if (opts->uid) > + seq_printf(m, ",uid=%u", > + from_kuid_munged(&init_user_ns, opts->fs_uid)); > + if (opts->gid) > + seq_printf(m, ",gid=%u", > + from_kgid_munged(&init_user_ns, opts->fs_gid)); > + if (opts->fmask) > + seq_printf(m, ",fmask=%04o", ~opts->fs_fmask_inv); > + if (opts->dmask) > + seq_printf(m, ",dmask=%04o", ~opts->fs_dmask_inv); > + if (sbi->nls[0]) > + seq_printf(m, ",nls=%s", sbi->nls[0]->charset); > + else > + seq_puts(m, ",nls=utf8"); > + if (sbi->nls[1]) > + seq_printf(m, ",nls_alt=%s", sbi->nls[1]->charset); > + if (opts->sys_immutable) > + seq_puts(m, ",sys_immutable"); > + if (opts->discard) > + seq_puts(m, ",discard"); > + if (opts->sparse) > + seq_puts(m, ",sparse"); > + if (opts->showmeta) > + seq_puts(m, ",showmeta"); > + if (opts->nohidden) > + seq_puts(m, ",nohidden"); > + if (opts->force) > + seq_puts(m, ",force"); > + if (opts->no_acs_rules) > + seq_puts(m, ",no_acs_rules"); > + if (opts->prealloc) > + seq_puts(m, ",prealloc"); > + if (sb->s_flags & SB_POSIXACL) > + seq_puts(m, ",acl"); > + if (sb->s_flags & SB_NOATIME) > + seq_puts(m, ",noatime"); > + > + return 0; > +} > + > +/*super_operations::sync_fs*/ > +static int ntfs_sync_fs(struct super_block *sb, int wait) > +{ > + int err = 0, err2; > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct ntfs_inode *ni; > + struct inode *inode; > + > + ni = sbi->security.ni; > + if (ni) { > + inode = &ni->vfs_inode; > + err2 = _ni_write_inode(inode, wait); > + if (err2 && !err) > + err = err2; > + } > + > + ni = sbi->objid.ni; > + if (ni) { > + inode = &ni->vfs_inode; > + err2 = _ni_write_inode(inode, wait); > + if (err2 && !err) > + err = err2; > + } > + > + ni = sbi->reparse.ni; > + if (ni) { > + inode = &ni->vfs_inode; > + err2 = _ni_write_inode(inode, wait); > + if (err2 && !err) > + err = err2; > + } > + > + if (!err) > + ntfs_set_state(sbi, NTFS_DIRTY_CLEAR); > + > + ntfs_update_mftmirr(sbi, wait); > + > + return err; > +} > + > +static const struct super_operations ntfs_sops = { > + .alloc_inode = ntfs_alloc_inode, > + .destroy_inode = ntfs_destroy_inode, > + .evict_inode = ntfs_evict_inode, > + .put_super = ntfs_put_super, > + .statfs = ntfs_statfs, > + .show_options = ntfs_show_options, > + .sync_fs = ntfs_sync_fs, > + .remount_fs = ntfs_remount, > + .write_inode = ntfs_write_inode, > +}; > + > +static struct inode *ntfs_export_get_inode(struct super_block *sb, u64 ino, > + u32 generation) > +{ > + struct MFT_REF ref; > + struct inode *inode; > + > + ref.low = cpu_to_le32(ino); > +#ifdef NTFS3_64BIT_CLUSTER > + ref.high = cpu_to_le16(ino >> 32); > +#else > + ref.high = 0; > +#endif > + ref.seq = cpu_to_le16(generation); > + > + inode = ntfs_iget5(sb, &ref, NULL); > + if (!IS_ERR(inode) && is_bad_inode(inode)) { > + iput(inode); > + inode = ERR_PTR(-ESTALE); > + } > + > + return inode; > +} > + > +static struct dentry *ntfs_fh_to_dentry(struct super_block *sb, struct fid *fid, > + int fh_len, int fh_type) > +{ > + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, > + ntfs_export_get_inode); > +} > + > +static struct dentry *ntfs_fh_to_parent(struct super_block *sb, struct fid *fid, > + int fh_len, int fh_type) > +{ > + return generic_fh_to_parent(sb, fid, fh_len, fh_type, > + ntfs_export_get_inode); > +} > + > +/* TODO: == ntfs_sync_inode */ > +static int ntfs_nfs_commit_metadata(struct inode *inode) > +{ > + return _ni_write_inode(inode, 1); > +} > + > +static const struct export_operations ntfs_export_ops = { > + .fh_to_dentry = ntfs_fh_to_dentry, > + .fh_to_parent = ntfs_fh_to_parent, > + .get_parent = ntfs_get_parent, > + .commit_metadata = ntfs_nfs_commit_metadata, > +}; > + > +/* Returns Gb,Mb to print with "%u.%02u Gb" */ > +static u32 format_size_gb(const u64 bytes, u32 *mb) > +{ > + /* Do simple right 30 bit shift of 64 bit value */ > + u64 kbytes = bytes >> 10; > + u32 kbytes32 = (u32)kbytes; > + > + *mb = (100 * (kbytes32 & 0xfffff) + 0x7ffff) >> 20; > + if (*mb >= 100) > + *mb = 99; > + > + return (kbytes32 >> 20) | (((u32)(kbytes >> 32)) << 12); > +} > + > +static u32 true_sectors_per_clst(const struct NTFS_BOOT *boot) > +{ > + return boot->sectors_per_clusters <= 0x80 ? > + boot->sectors_per_clusters : > + (1u << (0 - boot->sectors_per_clusters)); > +} > + > +/* inits internal info from on-disk boot sector*/ > +static int ntfs_init_from_boot(struct super_block *sb, u32 sector_size, > + u64 dev_size) > +{ > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + int err; > + u32 mb, gb, boot_sector_size, sct_per_clst, record_size; > + u64 sectors, clusters, fs_size, mlcn, mlcn2; > + struct NTFS_BOOT *boot; > + struct buffer_head *bh; > + struct MFT_REC *rec; > + u16 fn, ao; > + > + sbi->volume.blocks = dev_size >> PAGE_SHIFT; > + > + bh = ntfs_bread(sb, 0); > + if (!bh) > + return -EIO; > + > + err = -EINVAL; > + boot = (struct NTFS_BOOT *)bh->b_data; > + > + if (memcmp(boot->system_id, "NTFS ", sizeof("NTFS ") - 1)) > + goto out; > + > + /* 0x55AA is not mandaroty. Thanks Maxim Suhanov*/ > + /*if (0x55 != boot->boot_magic[0] || 0xAA != boot->boot_magic[1]) > + * goto out; > + */ > + > + boot_sector_size = (u32)boot->bytes_per_sector[1] << 8; > + if (boot->bytes_per_sector[0] || boot_sector_size < SECTOR_SIZE || > + !is_power_of2(boot_sector_size)) { > + goto out; > + } > + > + sct_per_clst = true_sectors_per_clst(boot); > + if (!is_power_of2(sct_per_clst)) > + goto out; > + > + mlcn = le64_to_cpu(boot->mft_clst); > + mlcn2 = le64_to_cpu(boot->mft2_clst); > + sectors = le64_to_cpu(boot->sectors_per_volume); > + > + if (mlcn * sct_per_clst >= sectors) > + goto out; > + > + if (mlcn2 * sct_per_clst >= sectors) > + goto out; > + > + /* Check MFT record size */ > + if ((boot->record_size < 0 && > + SECTOR_SIZE > (2U << (-boot->record_size))) || > + (boot->record_size >= 0 && !is_power_of2(boot->record_size))) { > + goto out; > + } > + > + /* Check index record size */ > + if ((boot->index_size < 0 && > + SECTOR_SIZE > (2U << (-boot->index_size))) || > + (boot->index_size >= 0 && !is_power_of2(boot->index_size))) { > + goto out; > + } > + > + sbi->sector_size = boot_sector_size; > + sbi->sector_bits = blksize_bits(boot_sector_size); > + fs_size = (sectors + 1) << sbi->sector_bits; > + > + gb = format_size_gb(fs_size, &mb); > + > + /* > + * - Volume formatted and mounted with the same sector size > + * - Volume formatted 4K and mounted as 512 > + * - Volume formatted 512 and mounted as 4K > + */ > + if (sbi->sector_size != sector_size) { > + ntfs_warn(sb, > + "Different NTFS' sector size and media sector size"); > + dev_size += sector_size - 1; > + } > + > + sbi->cluster_size = boot_sector_size * sct_per_clst; > + sbi->cluster_bits = blksize_bits(sbi->cluster_size); > + > + sbi->mft.lbo = mlcn << sbi->cluster_bits; > + sbi->mft.lbo2 = mlcn2 << sbi->cluster_bits; > + > + if (sbi->cluster_size < sbi->sector_size) > + goto out; > + > + sbi->cluster_mask = sbi->cluster_size - 1; > + sbi->cluster_mask_inv = ~(u64)sbi->cluster_mask; > + sbi->record_size = record_size = boot->record_size < 0 ? > + 1 << (-boot->record_size) : > + (u32)boot->record_size > + << sbi->cluster_bits; > + > + if (record_size > MAXIMUM_BYTES_PER_MFT) > + goto out; > + > + sbi->record_bits = blksize_bits(record_size); > + sbi->attr_size_tr = (5 * record_size >> 4); // ~320 bytes > + > + sbi->max_bytes_per_attr = > + record_size - QuadAlign(MFTRECORD_FIXUP_OFFSET_1) - > + QuadAlign(((record_size >> SECTOR_SHIFT) * sizeof(short))) - > + QuadAlign(sizeof(enum ATTR_TYPE)); > + > + sbi->index_size = boot->index_size < 0 ? > + 1u << (-boot->index_size) : > + (u32)boot->index_size << sbi->cluster_bits; > + > + sbi->volume.ser_num = le64_to_cpu(boot->serial_num); > + sbi->volume.size = sectors << sbi->sector_bits; > + > + /* warning if RAW volume */ > + if (dev_size < fs_size) { > + u32 mb0, gb0; > + > + gb0 = format_size_gb(dev_size, &mb0); > + ntfs_warn( > + sb, > + "RAW NTFS volume: Filesystem size %u.%02u Gb > volume size %u.%02u Gb. Mount in read-only", > + gb, mb, gb0, mb0); > + sb->s_flags |= SB_RDONLY; > + } > + > + clusters = sbi->volume.size >> sbi->cluster_bits; > +#ifdef NTFS3_64BIT_CLUSTER > +#if BITS_PER_LONG < 64 > +#error "NTFS3_64BIT_CLUSTER incompatible in 32 bit OS" > +#endif > +#else > + /* 32 bits per cluster */ > + if (clusters >> 32) { > + ntfs_notice( > + sb, > + "NTFS %u.%02u Gb is too big to use 32 bits per cluster", > + gb, mb); > + goto out; > + } > +#endif > + > + sbi->used.bitmap.nbits = clusters; > + > + rec = ntfs_alloc(record_size, 1); > + if (!rec) { > + err = -ENOMEM; > + goto out; > + } > + > + sbi->new_rec = rec; > + rec->rhdr.sign = NTFS_FILE_SIGNATURE; > + rec->rhdr.fix_off = cpu_to_le16(MFTRECORD_FIXUP_OFFSET_1); > + fn = (sbi->record_size >> SECTOR_SHIFT) + 1; > + rec->rhdr.fix_num = cpu_to_le16(fn); > + ao = QuadAlign(MFTRECORD_FIXUP_OFFSET_1 + sizeof(short) * fn); > + rec->attr_off = cpu_to_le16(ao); > + rec->used = cpu_to_le32(ao + QuadAlign(sizeof(enum ATTR_TYPE))); > + rec->total = cpu_to_le32(sbi->record_size); > + ((struct ATTRIB *)Add2Ptr(rec, ao))->type = ATTR_END; > + > + if (sbi->cluster_size < PAGE_SIZE) > + sb_set_blocksize(sb, sbi->cluster_size); > + > + sbi->block_mask = sb->s_blocksize - 1; > + sbi->blocks_per_cluster = sbi->cluster_size >> sb->s_blocksize_bits; > + sbi->volume.blocks = sbi->volume.size >> sb->s_blocksize_bits; > + > + /* Maximum size for normal files */ > + sbi->maxbytes = (clusters << sbi->cluster_bits) - 1; > + > +#ifdef NTFS3_64BIT_CLUSTER > + if (clusters >= (1ull << (64 - sbi->cluster_bits))) > + sbi->maxbytes = -1; > + sbi->maxbytes_sparse = -1; > +#else > + /* Maximum size for sparse file */ > + sbi->maxbytes_sparse = (1ull << (sbi->cluster_bits + 32)) - 1; > +#endif > + > + err = 0; > + > +out: > + brelse(bh); > + > + return err; > +} > + > +enum Opt { > + Opt_uid, > + Opt_gid, > + Opt_umask, > + Opt_dmask, > + Opt_fmask, > + Opt_immutable, > + Opt_discard, > + Opt_force, > + Opt_sparse, > + Opt_nohidden, > + Opt_showmeta, > + Opt_acl, > + Opt_noatime, > + Opt_nls, > + Opt_nls_alt, > + Opt_prealloc, > + Opt_no_acs_rules, > + Opt_err, > +}; > + > +static const match_table_t fat_tokens = { { Opt_uid, "uid=%u" }, > + { Opt_gid, "gid=%u" }, > + { Opt_umask, "umask=%o" }, > + { Opt_dmask, "dmask=%o" }, > + { Opt_fmask, "fmask=%o" }, > + { Opt_immutable, "sys_immutable" }, > + { Opt_discard, "discard" }, > + { Opt_force, "force" }, > + { Opt_sparse, "sparse" }, > + { Opt_nohidden, "nohidden" }, > + { Opt_acl, "acl" }, > + { Opt_noatime, "noatime" }, > + { Opt_showmeta, "showmeta" }, > + { Opt_nls, "nls=%s" }, > + { Opt_nls_alt, "nls_alt=%s" }, > + { Opt_prealloc, "prealloc" }, > + { Opt_no_acs_rules, "no_acs_rules" }, > + { Opt_err, NULL } }; > + > +static noinline int ntfs_parse_options(struct super_block *sb, char *options, > + int silent, struct mount_options *opts) > +{ > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + char *p; > + substring_t args[MAX_OPT_ARGS]; > + int i, option; > + char nls_name[2][30]; > + > + opts->fs_uid = current_uid(); > + opts->fs_gid = current_gid(); > + opts->fs_fmask_inv = opts->fs_dmask_inv = ~current_umask(); > + nls_name[0][0] = 0; > + nls_name[1][0] = 0; > + > + if (!options) > + goto out; > + > + while ((p = strsep(&options, ","))) { > + int token; > + > + if (!*p) > + continue; > + > + token = match_token(p, fat_tokens, args); > + switch (token) { > + case Opt_immutable: > + opts->sys_immutable = 1; > + break; > + case Opt_uid: > + if (match_int(&args[0], &option)) > + return -EINVAL; > + opts->fs_uid = make_kuid(current_user_ns(), option); > + if (!uid_valid(opts->fs_uid)) > + return -EINVAL; > + opts->uid = 1; > + break; > + case Opt_gid: > + if (match_int(&args[0], &option)) > + return -EINVAL; > + opts->fs_gid = make_kgid(current_user_ns(), option); > + if (!gid_valid(opts->fs_gid)) > + return -EINVAL; > + opts->gid = 1; > + break; > + case Opt_umask: > + if (match_octal(&args[0], &option)) > + return -EINVAL; > + opts->fs_fmask_inv = opts->fs_dmask_inv = ~option; > + opts->fmask = opts->dmask = 1; > + break; > + case Opt_dmask: > + if (match_octal(&args[0], &option)) > + return -EINVAL; > + opts->fs_dmask_inv = ~option; > + opts->dmask = 1; > + break; > + case Opt_fmask: > + if (match_octal(&args[0], &option)) > + return -EINVAL; > + opts->fs_fmask_inv = ~option; > + opts->fmask = 1; > + break; > + case Opt_discard: > + opts->discard = 1; > + break; > + case Opt_force: > + opts->force = 1; > + break; > + case Opt_sparse: > + opts->sparse = 1; > + break; > + case Opt_nohidden: > + opts->nohidden = 1; > + break; > + case Opt_acl: > + sb->s_flags |= SB_POSIXACL; > + break; > + case Opt_noatime: > + sb->s_flags |= SB_NOATIME; > + break; > + case Opt_showmeta: > + opts->showmeta = 1; > + break; > + case Opt_nls: > + case Opt_nls_alt: > + match_strlcpy(nls_name[token == Opt_nls_alt], &args[0], > + sizeof(nls_name[0])); > + break; > + case Opt_prealloc: > + opts->prealloc = 1; > + break; > + case Opt_no_acs_rules: > + opts->no_acs_rules = 1; > + break; > + default: > + if (!silent) > + ntfs_err( > + sb, > + "Unrecognized mount option \"%s\" or missing value", > + p); > + //return -EINVAL; > + } > + } > + > +out: > + > + for (i = 0; i < ARRAY_SIZE(sbi->nls); i++) { > + struct nls_table *nls; > + > + if (nls_name[i][0]) { > + nls = load_nls(nls_name[i]); > + if (!nls) { > + ntfs_err(sb, "failed to load \"%s\"", > + nls_name[i]); > + return -EINVAL; > + } > + } else { > + nls = load_nls_default(); > + if (!nls) { > + ntfs_err(sb, "failed to load default nls"); > + return -EINVAL; > + } > + } > + > + sbi->nls[i] = nls; > + } > + > + /* unload alternative nls if it equals primary one */ > + if (!strcmp(sbi->nls[0]->charset, sbi->nls[1]->charset)) { > + unload_nls(sbi->nls[1]); > + sbi->nls[1] = NULL; > + } > + > + if (!strcmp(sbi->nls[0]->charset, "utf8")) { > + /*use utf16s_to_utf8s/utf8s_to_utf16s instead of nls*/ > + unload_nls(sbi->nls[0]); > + sbi->nls[0] = NULL; > + } > + > + return 0; > +} > + > +/* try to mount*/ > +static int ntfs_fill_super(struct super_block *sb, void *data, int silent) > +{ > + int err; > + struct ntfs_sb_info *sbi; > + struct block_device *bdev = sb->s_bdev; > + struct inode *bd_inode = bdev->bd_inode; > + struct request_queue *rq = bdev_get_queue(bdev); > + struct inode *inode = NULL; > + struct ntfs_inode *ni; > + size_t i, tt; > + CLST vcn, lcn, len; > + struct ATTRIB *attr; > + const struct VOLUME_INFO *info; > + u32 idx, done, bytes; > + struct ATTR_DEF_ENTRY *t; > + u16 *upcase = NULL; > + u16 *shared; > + bool is_ro; > + struct MFT_REF ref; > + > + ref.high = 0; > + > + sbi = ntfs_alloc(sizeof(struct ntfs_sb_info), true); > + if (!sbi) > + return -ENOMEM; > + > + sb->s_fs_info = sbi; > + sbi->sb = sb; > + sb->s_flags |= SB_NODIRATIME; > + sb->s_magic = 0x337366746e; // "ntfs3" > + sb->s_op = &ntfs_sops; > + sb->s_export_op = &ntfs_export_ops; > + sb->s_time_gran = NTFS_TIME_GRAN; // 100 nsec > + sb->s_xattr = ntfs_xattr_handlers; > + sb->s_maxbytes = MAX_LFS_FILESIZE; > + > + ratelimit_state_init(&sbi->msg_ratelimit, DEFAULT_RATELIMIT_INTERVAL, > + DEFAULT_RATELIMIT_BURST); > + > + err = ntfs_parse_options(sb, data, silent, &sbi->options); > + if (err) > + goto out; > + > + if (!rq || !blk_queue_discard(rq) || !rq->limits.discard_granularity) { > + ; > + } else { > + sbi->discard_granularity = rq->limits.discard_granularity; > + sbi->discard_granularity_mask_inv = > + ~(u64)(sbi->discard_granularity - 1); > + } > + > + sb_set_blocksize(sb, PAGE_SIZE); > + > + /* parse boot */ > + err = ntfs_init_from_boot(sb, rq ? queue_logical_block_size(rq) : 512, > + bd_inode->i_size); > + if (err) > + goto out; > + > + spin_lock_init(&sbi->compress.lock); > + if (sbi->cluster_size <= NTFS_LZNT_MAX_CLUSTER) { > + sbi->compress.frame_unc = > + ntfs_alloc(sbi->cluster_size << NTFS_LZNT_CUNIT, 0); > + if (!sbi->compress.frame_unc) { > + err = -ENOMEM; > + goto out; > + } > + > + sbi->compress.ctx = get_compression_ctx(true); > + if (!sbi->compress.ctx) { > + err = -ENOMEM; > + goto out; > + } > + } > + > + /* > + * Load $Volume. This should be done before $LogFile > + * 'cause 'sbi->volume.ni' is used 'ntfs_set_state' > + */ > + ref.low = cpu_to_le32(MFT_REC_VOL); > + ref.seq = cpu_to_le16(MFT_REC_VOL); > + inode = ntfs_iget5(sb, &ref, &NAME_VOLUME); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $Volume."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + /* Load and save label (not necessary) */ > + attr = ni_find_attr(ni, NULL, NULL, ATTR_LABEL, NULL, 0, NULL, NULL); > + > + if (!attr) { > + ; > + } else if (!attr->non_res && !is_attr_ext(attr)) { > + /* $AttrDef allows labels to be up to 128 symbols */ > + err = utf16s_to_utf8s(resident_data(attr), > + le32_to_cpu(attr->res.data_size) >> 1, > + UTF16_LITTLE_ENDIAN, sbi->volume.label, > + sizeof(sbi->volume.label)); > + if (err < 0) > + sbi->volume.label[0] = 0; > + } else { > + /* should we break mounting here? */ > + //err = -EINVAL; > + //goto out; > + } > + > + attr = ni_find_attr(ni, attr, NULL, ATTR_VOL_INFO, NULL, 0, NULL, NULL); > + if (!attr || is_attr_ext(attr)) { > + err = -EINVAL; > + goto out; > + } > + > + info = resident_data_ex(attr, SIZEOF_ATTRIBUTE_VOLUME_INFO); > + if (!info) { > + err = -EINVAL; > + goto out; > + } > + > + sbi->volume.major_ver = info->major_ver; > + sbi->volume.minor_ver = info->minor_ver; > + sbi->volume.flags = info->flags; > + > + sbi->volume.ni = ni; > + inode = NULL; > + > + /* Load $MFTMirr to estimate recs_mirr */ > + ref.low = cpu_to_le32(MFT_REC_MIRR); > + ref.seq = cpu_to_le16(MFT_REC_MIRR); > + inode = ntfs_iget5(sb, &ref, &NAME_MIRROR); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $MFTMirr."); > + inode = NULL; > + goto out; > + } > + > + sbi->mft.recs_mirr = > + ntfs_up_cluster(sbi, inode->i_size) >> sbi->record_bits; > + > + iput(inode); > + > + /* Load $LogFile to replay */ > + ref.low = cpu_to_le32(MFT_REC_LOG); > + ref.seq = cpu_to_le16(MFT_REC_LOG); > + inode = ntfs_iget5(sb, &ref, &NAME_LOGFILE); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $LogFile."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + err = ntfs_loadlog_and_replay(ni, sbi); > + if (err) > + goto out; > + > + iput(inode); > + inode = NULL; > + > + is_ro = sb_rdonly(sbi->sb); > + > + if (sbi->flags & NTFS_FLAGS_NEED_REPLAY) { > + if (!is_ro) { > + ntfs_warn(sb, > + "failed to replay log file. Can't mount rw!"); > + err = -EINVAL; > + goto out; > + } > + } else if (sbi->volume.flags & VOLUME_FLAG_DIRTY) { > + if (!is_ro && !sbi->options.force) { > + ntfs_warn( > + sb, > + "volume is dirty and \"force\" flag is not set!"); > + err = -EINVAL; > + goto out; > + } > + } > + > + /* Load $MFT */ > + ref.low = cpu_to_le32(MFT_REC_MFT); > + ref.seq = cpu_to_le16(1); > + > + inode = ntfs_iget5(sb, &ref, &NAME_MFT); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $MFT."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + sbi->mft.used = ni->i_valid >> sbi->record_bits; > + tt = inode->i_size >> sbi->record_bits; > + sbi->mft.next_free = MFT_REC_USER; > + > + err = wnd_init(&sbi->mft.bitmap, sb, tt); > + if (err) > + goto out; > + > + err = ni_load_all_mi(ni); > + if (err) > + goto out; > + > + sbi->mft.ni = ni; > + > + /* Load $BadClus */ > + ref.low = cpu_to_le32(MFT_REC_BADCLUST); > + ref.seq = cpu_to_le16(MFT_REC_BADCLUST); > + inode = ntfs_iget5(sb, &ref, &NAME_BADCLUS); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $BadClus."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + for (i = 0; run_get_entry(&ni->file.run, i, &vcn, &lcn, &len); i++) { > + if (lcn == SPARSE_LCN) > + continue; > + > + if (!sbi->bad_clusters) > + ntfs_notice(sb, "Volume contains bad blocks"); > + > + sbi->bad_clusters += len; > + } > + > + iput(inode); > + > + /* Load $Bitmap */ > + ref.low = cpu_to_le32(MFT_REC_BITMAP); > + ref.seq = cpu_to_le16(MFT_REC_BITMAP); > + inode = ntfs_iget5(sb, &ref, &NAME_BITMAP); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $Bitmap."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > +#ifndef NTFS3_64BIT_CLUSTER > + if (inode->i_size >> 32) { > + err = -EINVAL; > + goto out; > + } > +#endif > + > + /* Check bitmap boundary */ > + tt = sbi->used.bitmap.nbits; > + if (inode->i_size < bitmap_size(tt)) { > + err = -EINVAL; > + goto out; > + } > + > + /* Not necessary */ > + sbi->used.bitmap.set_tail = true; > + err = wnd_init(&sbi->used.bitmap, sbi->sb, tt); > + if (err) > + goto out; > + > + iput(inode); > + > + /* Compute the mft zone */ > + err = ntfs_refresh_zone(sbi); > + if (err) > + goto out; > + > + /* Load $AttrDef */ > + ref.low = cpu_to_le32(MFT_REC_ATTR); > + ref.seq = cpu_to_le16(MFT_REC_ATTR); > + inode = ntfs_iget5(sbi->sb, &ref, &NAME_ATTRDEF); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $AttrDef -> %d", err); > + inode = NULL; > + goto out; > + } > + > + if (inode->i_size < sizeof(struct ATTR_DEF_ENTRY)) { > + err = -EINVAL; > + goto out; > + } > + bytes = inode->i_size; > + sbi->def_table = t = ntfs_alloc(bytes, 0); > + if (!t) { > + err = -ENOMEM; > + goto out; > + } > + > + for (done = idx = 0; done < bytes; done += PAGE_SIZE, idx++) { > + unsigned long tail = bytes - done; > + struct page *page = ntfs_map_page(inode->i_mapping, idx); > + > + if (IS_ERR(page)) { > + err = PTR_ERR(page); > + goto out; > + } > + memcpy(Add2Ptr(t, done), page_address(page), > + min(PAGE_SIZE, tail)); > + ntfs_unmap_page(page); > + > + if (!idx && ATTR_STD != t->type) { > + err = -EINVAL; > + goto out; > + } > + } > + > + t += 1; > + sbi->def_entries = 1; > + done = sizeof(struct ATTR_DEF_ENTRY); > + sbi->reparse.max_size = MAXIMUM_REPARSE_DATA_BUFFER_SIZE; > + > + while (done + sizeof(struct ATTR_DEF_ENTRY) <= bytes) { > + u32 t32 = le32_to_cpu(t->type); > + > + if ((t32 & 0xF) || le32_to_cpu(t[-1].type) >= t32) > + break; > + > + if (t->type == ATTR_REPARSE) > + sbi->reparse.max_size = le64_to_cpu(t->max_sz); > + > + done += sizeof(struct ATTR_DEF_ENTRY); > + t += 1; > + sbi->def_entries += 1; > + } > + iput(inode); > + > + /* Load $UpCase */ > + ref.low = cpu_to_le32(MFT_REC_UPCASE); > + ref.seq = cpu_to_le16(MFT_REC_UPCASE); > + inode = ntfs_iget5(sb, &ref, &NAME_UPCASE); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load $LogFile."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + if (inode->i_size != 0x10000 * sizeof(short)) { > + err = -EINVAL; > + goto out; > + } > + > + page_cache_readahead_unbounded(inode->i_mapping, NULL, 0, > + 0x10000 * sizeof(short) / PAGE_SIZE, 0); > + > + sbi->upcase = upcase = ntfs_alloc(0x10000 * sizeof(short), 0); > + if (!upcase) { > + err = -ENOMEM; > + goto out; > + } > + > + for (idx = 0; idx < (0x10000 * sizeof(short) >> PAGE_SHIFT); idx++) { > + const u16 *src; > + u16 *dst = Add2Ptr(upcase, idx << PAGE_SHIFT); > + struct page *page = ntfs_map_page(inode->i_mapping, idx); > + > + if (IS_ERR(page)) { > + err = PTR_ERR(page); > + goto out; > + } > + > + src = page_address(page); > + > +#ifdef __BIG_ENDIAN > + for (i = 0; i < PAGE_SIZE / sizeof(u16); i++) > + *dst++ = le16_to_cpu(*src++); > +#else > + memcpy(dst, src, PAGE_SIZE); > +#endif > + ntfs_unmap_page(page); > + } > + > + shared = ntfs_set_shared(upcase, 0x10000 * sizeof(short)); > + if (shared && upcase != shared) { > + sbi->upcase = shared; > + ntfs_free(upcase); > + } > + > + iput(inode); > + inode = NULL; > + > + if (is_ntfs3(sbi)) { > + /* Load $Secure */ > + err = ntfs_security_init(sbi); > + if (err) > + goto out; > + > + /* Load $Extend */ > + err = ntfs_extend_init(sbi); > + if (err) > + goto load_root; > + > + /* Load $Extend\$Reparse */ > + err = ntfs_reparse_init(sbi); > + if (err) > + goto load_root; > + > + /* Load $Extend\$ObjId */ > + err = ntfs_objid_init(sbi); > + if (err) > + goto load_root; > + } > + > +load_root: > + > + /* Load root */ > + ref.low = cpu_to_le32(MFT_REC_ROOT); > + ref.seq = cpu_to_le16(MFT_REC_ROOT); > + inode = ntfs_iget5(sb, &ref, &NAME_ROOT); > + if (IS_ERR(inode)) { > + err = PTR_ERR(inode); > + ntfs_err(sb, "Failed to load root."); > + inode = NULL; > + goto out; > + } > + > + ni = ntfs_i(inode); > + > + sb->s_root = d_make_root(inode); > + > + if (!sb->s_root) { > + err = -EINVAL; > + goto out; > + } > + > + return 0; > + > +out: > + iput(inode); > + > + if (sb->s_root) { > + d_drop(sb->s_root); > + sb->s_root = NULL; > + } > + > + put_ntfs(sbi); > + > + sb->s_fs_info = NULL; > + return err; > +} > + > +void ntfs_unmap_meta(struct super_block *sb, CLST lcn, CLST len) > +{ > + struct ntfs_sb_info *sbi = sb->s_fs_info; > + struct block_device *bdev = sb->s_bdev; > + sector_t devblock = (u64)lcn * sbi->blocks_per_cluster; > + unsigned long blocks = (u64)len * sbi->blocks_per_cluster; > + unsigned long cnt = 0; > + unsigned long limit = global_zone_page_state(NR_FREE_PAGES) > + << (PAGE_SHIFT - sb->s_blocksize_bits); > + > + if (limit >= 0x2000) > + limit -= 0x1000; > + else if (limit < 32) > + limit = 32; > + else > + limit >>= 1; > + > + while (blocks--) { > + clean_bdev_aliases(bdev, devblock++, 1); > + if (cnt++ >= limit) { > + sync_blockdev(bdev); > + cnt = 0; > + } > + } > +} > + > +/* > + * ntfs_discard > + * > + * issue a discard request (trim for SSD) > + */ > +int ntfs_discard(struct ntfs_sb_info *sbi, CLST lcn, CLST len) > +{ > + int err; > + u64 lbo, bytes, start, end; > + struct super_block *sb; > + > + if (sbi->used.next_free_lcn == lcn + len) > + sbi->used.next_free_lcn = lcn; > + > + if (sbi->flags & NTFS_FLAGS_NODISCARD) > + return -EOPNOTSUPP; > + > + if (!sbi->options.discard) > + return -EOPNOTSUPP; > + > + lbo = (u64)lcn << sbi->cluster_bits; > + bytes = (u64)len << sbi->cluster_bits; > + > + /* Align up 'start' on discard_granularity */ > + start = (lbo + sbi->discard_granularity - 1) & > + sbi->discard_granularity_mask_inv; > + /* Align down 'end' on discard_granularity */ > + end = (lbo + bytes) & sbi->discard_granularity_mask_inv; > + > + sb = sbi->sb; > + if (start >= end) > + return 0; > + > + err = blkdev_issue_discard(sb->s_bdev, start >> 9, (end - start) >> 9, > + GFP_NOFS, 0); > + > + if (err == -EOPNOTSUPP) > + sbi->flags |= NTFS_FLAGS_NODISCARD; > + > + return err; > +} > + > +static struct dentry *ntfs_mount(struct file_system_type *fs_type, int flags, > + const char *dev_name, void *data) > +{ > + return mount_bdev(fs_type, flags, dev_name, data, ntfs_fill_super); > +} > + > +static struct file_system_type ntfs_fs_type = { > + .owner = THIS_MODULE, > + .name = "ntfs3", > + .mount = ntfs_mount, > + .kill_sb = kill_block_super, > + .fs_flags = FS_REQUIRES_DEV, > +}; > + > +static int __init init_ntfs_fs(void) > +{ > + int err; > + > +#ifdef NTFS3_INDEX_BINARY_SEARCH > + pr_notice("ntfs3: +index binary search"); > +#endif > + > +#ifdef NTFS3_CHECK_FREE_CLST > + pr_notice("ntfs3: +check free clusters"); > +#endif > + > +#if NTFS_LINK_MAX < 0xffff > + pr_notice("ntfs3: max link count %u", NTFS_LINK_MAX); > +#endif > + > +#ifdef NTFS3_64BIT_CLUSTER > + pr_notice("ntfs3: 64 bits per cluster"); > +#else > + pr_notice("ntfs3: 32 bits per cluster"); > +#endif > + > + ntfs_inode_cachep = kmem_cache_create( > + "ntfs_inode_cache", sizeof(struct ntfs_inode), 0, > + (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT), > + init_once); > + if (!ntfs_inode_cachep) { > + err = -ENOMEM; > + goto failed; > + } > + > + err = register_filesystem(&ntfs_fs_type); > + if (!err) > + return 0; > + > +failed: > + return err; > +} > + > +static void __exit exit_ntfs_fs(void) > +{ > + if (ntfs_inode_cachep) { > + rcu_barrier(); > + kmem_cache_destroy(ntfs_inode_cachep); > + } > + > + unregister_filesystem(&ntfs_fs_type); > +} > + > +MODULE_LICENSE("GPL"); > +MODULE_DESCRIPTION("ntfs3 filesystem"); > +MODULE_AUTHOR("Konstantin Komarov"); > +MODULE_ALIAS_FS("ntfs3"); > + > +module_init(init_ntfs_fs) module_exit(exit_ntfs_fs)