From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-pf1-f175.google.com (mail-pf1-f175.google.com [209.85.210.175]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9E6F0313E34 for ; Sat, 11 Jul 2026 20:59:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.175 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783803565; cv=none; b=IGKZa1Dm/HVFh0vS+kNcAeqnF7tWceYmMN3EizWHbWEaMs7qFVHn2ynqFngCDsvn/8s9papar6FA69Ub21jAfrBGIeIZYX0htKJCS8o+GBX/4aG2MwHTyivZQolM/CN0UBE58XmjgoIuwtrmJTlE80lsX1BG07Rs/LeCiAOmO2Y= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783803565; c=relaxed/simple; bh=kw0OMQMrjvlSwGKPOoDzAWrf75ZhL3wz/Mmj/2mK3do=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=X2yVw1EuU3bnmjlm5aw6YUQ8S5wgrxq1jOXEcYaTD7778+lO+r+mTEJ+Xgimz63mUpgJB5ovxwXROiqNqiP7JvjAKHLjymfRm/siCB8tcvrCAUauItRWNsXgIQSdCEXhQW9aqScFS10u7gTXgqRqahmSzFZY0g6rrzg3EBaOoY8= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=a2WghIb5; arc=none smtp.client-ip=209.85.210.175 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="a2WghIb5" Received: by mail-pf1-f175.google.com with SMTP id d2e1a72fcca58-8485b358552so2145349b3a.2 for ; Sat, 11 Jul 2026 13:59:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1783803563; x=1784408363; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=e6t8DGVkdCLYUd0OR5aV/ertEnot2rifntCQT4Agz04=; b=a2WghIb5NZ2KYgmDdfhNud/2TV89IhAV3nTHRBAHvoHHRB/k4w7re3CW+YLJhNV+yL scm510K4hoJkkoiJ9PhJM49+0mijT77i2OTzqkOwChCsfAW4YaEFLwsCK62voSleviTK fjEB1llmd5KNpGoEmJq3l1BiIIu12GQAT0lJNHYFe1NA7iwha3F2eOQUdyTGWXA41gA0 bzCP7hkPjf9CDUFjdKndiGiaElDOhhrEZcu5x/GCX4O0qjwT3vQihRlF/kTMdIfF0MqY 85Yx8SPVhdQv73+SbI5getizQawVQYzzhZ3djhGnIY0jm373Oru39PwhXqgV/qlbVBoB nbJQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1783803563; x=1784408363; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=e6t8DGVkdCLYUd0OR5aV/ertEnot2rifntCQT4Agz04=; b=ZbTXliVmN5Nm/ofp8JCw9WMgVzNJtOi3Q6FzrcsQZX3tHA6CnOLU/3hGrPoin20AlP R0hIJSqUa+KFw1o9xHsOy17daaJMEHCkyY79RO2zR6gjYfS3fxuB6nC+IAzWZjNz1CZz FHBTj7zh+KXmJejEDBrIqkv8qJPgT+fZ2ZbcJQORYOcWvZX8NVvADwTM375+YXtrhl7D BqPT6reI/95+gorU6i59Rb366hm0BnchGW9xamGeJ/FPVHb1m9EU++eNOA0ZCTZRr068 MtWbWkt0ySxm6xk/8osX8qnUNzdXQK9Q3evLAdyTvkwDlyLLIxBFL6iGh+B2as5T6DgG aWFA== X-Gm-Message-State: AOJu0YwIjR9lzXLJ9eGUzEwl40sABOtRDEDCuEWu4Q0Zcc/DiGesgQh4 xbpfQv6CpHIdftPlV5SBMuDfCvQFLsG8u/rwVai+GfXFBbh3qIvZRa6q X-Gm-Gg: AfdE7ckZUM22StlWxlu9eN5bJqRW8AdIcKqYbNurGBXaDBIIG2x7dUEcgP8GHH9a/Ti D1XCZn++jNhhSzQPXJiMpPQhjpCXjwmoeWhEbgZ/eMQ82rjD7/jjpIkizD3By1dQGsJtSqoP0Jq Tz95pL5c2vVDBXwNa5ckZHuoLnJlQY7U1g7QsKd6du/9P5JNtjS3qePkQAxHtvBC9ouw76mlluE Ao/y3K7HkNm4sbTPu2HoBOWrV2S5vgz1ScwcaWzW/oDrPQL1QI8zM2Sy0ixNKA8M7q80xVdr/Fq N0UlkQNLuks0CvEl+vHw8sVDE6Zn3AQkhbrc0lNdtfwJ9YnihycqlU8v8CGM8X942oXjk8xbu+u AYaiQgrfBEeUzxQnQH8eSHv2GVoeQUdjSacRIPz1AJNvD/U6WbhrfBkEWP3zZHRw= X-Received: by 2002:a05:6a00:802:b0:848:2f84:734 with SMTP id d2e1a72fcca58-8488990c921mr4151313b3a.71.1783803562857; Sat, 11 Jul 2026 13:59:22 -0700 (PDT) Received: from nineveh.sos.local ([131.191.24.68]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-84880a44feasm2092057b3a.20.2026.07.11.13.59.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 11 Jul 2026 13:59:22 -0700 (PDT) From: Jeremy Bingham To: linux-fsdevel@vger.kernel.org Cc: linux-kernel@vger.kernel.org, brauner@kernel.org, jkoolstra@xs4all.nl, jack@suse.cz, djwong@kernel.org, viro@zeniv.linux.org.uk, Jeremy Bingham Subject: [PATCH v3 2/5] minix: add base iomap begin/end functions Date: Sat, 11 Jul 2026 13:59:06 -0700 Message-ID: <555d199291b37e5c1241df648b3adcd760c1fca6.1783707063.git.jbingham@gmail.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Adds a new file, iomap.c, to fs/minix. This provides minix_iomap_begin, which is the iomap-based version of get_block in itree_common.c. It also provides minix_iomap_end, which is a no-op but required by the iomap_ops struct. This also undoes the nest of gotos inherited from get_block and uses a set of helper functions instead. Suggested-by: Darrick J. Wong Signed-off-by: Jeremy Bingham --- fs/minix/iomap.c | 122 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 fs/minix/iomap.c diff --git a/fs/minix/iomap.c b/fs/minix/iomap.c new file mode 100644 index 000000000000..90e016aaa01e --- /dev/null +++ b/fs/minix/iomap.c @@ -0,0 +1,122 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * iomap functions for minix. + */ + +static inline void minix_chain_cleanup(Indirect *chain, Indirect *partial) +{ + while (partial > chain) { + brelse(partial->bh); + partial--; + } +} + +static inline void minix_iomap_set_mapped(struct iomap *iomap, sector_t phys, + unsigned int blkbits, sector_t iblock) +{ + iomap->type = IOMAP_MAPPED; + iomap->addr = (u64)phys << blkbits; + iomap->length = 1 << blkbits; + iomap->offset = (u64)iblock << blkbits; +} + +static inline void minix_iomap_set_hole(struct iomap *iomap, + unsigned int blkbits, sector_t iblock) +{ + iomap->type = IOMAP_HOLE; + iomap->addr = IOMAP_NULL_ADDR; + iomap->length = 1 << blkbits; + iomap->offset = (u64)iblock << blkbits; +} + +/* + * minix_iomap_begin - map a file range to disk blocks. It acts as a replacement + * for get_block in itree_common.c, at least in the important ways, and is + * adapted from it, but it uses iomap instead of buffer_head. + */ +static int minix_iomap_begin(struct inode *inode, loff_t offset, loff_t length, + unsigned int flags, struct iomap *iomap, struct iomap *srcmap) +{ + struct super_block *sb = inode->i_sb; + unsigned int blkbits = sb->s_blocksize_bits; + sector_t iblock = offset >> blkbits; + int create = flags & IOMAP_WRITE; + + int offsets[DEPTH]; + Indirect chain[DEPTH]; + Indirect *partial; + int depth = block_to_path(inode, iblock, offsets); + int left; + int err = -EIO; + + sector_t phys; + + /* block is beyond max file size */ + if (depth == 0) + return -EINVAL; + + iomap->bdev = inode->i_sb->s_bdev; + +reread: + partial = get_branch(inode, depth, offsets, chain, &err); + + /* Simplest case - block found, no allocation needed */ + if (!partial) { + iomap->flags = 0; + phys = block_to_cpu(chain[depth - 1].key); + partial = chain+depth-1; + minix_iomap_set_mapped(iomap, phys, blkbits, iblock); + minix_chain_cleanup(chain, partial); + return err; + } + + /* Next simple case - plain lookup or failed read of indirect block */ + if (!create || err == -EIO) { + minix_iomap_set_hole(iomap, blkbits, iblock); + minix_chain_cleanup(chain, partial); + return err; + } + + /* + * This is held over from the original get_block logic, where it + * acted as a guard in case truncate() deleted blocks from under that + * function. There should not be a race with iomap operations, but + * we're retaining the defensive coding here to be extra safe just in + * case. + */ + if (err == -EAGAIN) { + minix_chain_cleanup(chain, partial); + goto reread; + } + + left = (chain + depth) - partial; + err = alloc_branch(inode, left, offsets + (partial - chain), partial); + if (err) { + minix_chain_cleanup(chain, partial); + return err; + } + + if (splice_branch(inode, chain, partial, left) < 0) { + minix_chain_cleanup(chain, partial); + goto reread; + } + + /* Successful allocation, mapping it. */ + iomap->flags = IOMAP_F_NEW; + phys = block_to_cpu(chain[depth - 1].key); + minix_iomap_set_mapped(iomap, phys, blkbits, iblock); + minix_chain_cleanup(chain, partial); + + return err; +} + +/* + * minix_iomap_end ends up being a nop; since minix doesn't have any extents or + * transactions to worry about, there isn't anything to update here. The on-disk + * indirect blocks get dirtied in minix_iomap_begin. + */ +static int minix_iomap_end(struct inode *inode, loff_t offset, loff_t length, + ssize_t written, unsigned int flags, struct iomap *iomap) +{ + return 0; +} -- 2.47.3