* [PATCH 09/13] mke2fs/tune2fs: add dirdata feature support
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Add user-facing feature support for dirdata in filesystem creation and
modification tools. Users can now create filesystems with the dirdata feature
or enable it on existing filesystems.
Usage examples:
mke2fs -O dirdata /dev/sda1 # Create filesystem with dirdata
tune2fs -O dirdata /dev/sda1 # Enable dirdata on existing filesystem
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
e2fsck/pass2.c | 3 +--
lib/ext2fs/dirblock.c | 7 ++++---
lib/ext2fs/ext2fs.h | 2 +-
misc/mke2fs.c | 1 +
misc/tune2fs.c | 2 ++
5 files changed, 9 insertions(+), 6 deletions(-)
diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index 938942a80..9a0f6f772 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -435,8 +435,7 @@ void ext2_fix_dirent_dirdata(struct ext2_dir_entry *de)
int e2fsck_check_dirent_data(e2fsck_t ctx, struct ext2_dir_entry *de,
unsigned int offset, struct problem_context *pctx)
{
- if (!(ctx->fs->super->s_feature_incompat &
- EXT4_FEATURE_INCOMPAT_DIRDATA)) {
+ if (!ext2fs_has_feature_dirdata(ctx->fs->super)) {
if ((de->name_len >> 8) & ~EXT2_FT_MASK) {
/* clear dirent extra data flags. */
if (fix_problem(ctx, PR_2_CLEAR_DIRDATA, pctx)) {
diff --git a/lib/ext2fs/dirblock.c b/lib/ext2fs/dirblock.c
index d1d5a9e7f..fa7cc83ff 100644
--- a/lib/ext2fs/dirblock.c
+++ b/lib/ext2fs/dirblock.c
@@ -74,13 +74,14 @@ int ext2_get_dirdata_field_size(struct ext2_dir_entry *de,
dirdata_flags >>= 1;
}
- /* add NUL terminator byte to dirdata length */
- return dlen + (dlen != 0);
+ return dlen;
}
int ext2_get_dirdata_size(struct ext2_dir_entry *de)
{
- return ext2_get_dirdata_field_size(de, ~EXT2_FT_MASK);
+ int size = ext2_get_dirdata_field_size(de, ~EXT2_FT_MASK);
+ /* Add 1 becasue NULL after the name */
+ return size + (size ? 1 : 0);
}
errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index cf12716e3..b14ba0a34 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -2276,7 +2276,7 @@ _INLINE_ struct ext2_dx_root_info *ext2fs_get_dx_root_info(ext2_filsys fs,
de = (struct ext2_dir_entry *)((char *)de + de->rec_len);
/* dx root info is after dotdot entry */
- de = EXT2_NEXT_DIRENT(de);
+ de = (struct ext2_dir_entry *)((char *)de + EXT2_DIRENT_REC_LEN(de));
return (struct ext2_dx_root_info *)de;
}
diff --git a/misc/mke2fs.c b/misc/mke2fs.c
index dd8c53d90..2bcb7036e 100644
--- a/misc/mke2fs.c
+++ b/misc/mke2fs.c
@@ -1279,6 +1279,7 @@ static __u32 ok_features[3] = {
EXT4_FEATURE_INCOMPAT_FLEX_BG|
EXT4_FEATURE_INCOMPAT_EA_INODE|
EXT4_FEATURE_INCOMPAT_MMP |
+ EXT4_FEATURE_INCOMPAT_DIRDATA|
EXT4_FEATURE_INCOMPAT_64BIT|
EXT4_FEATURE_INCOMPAT_INLINE_DATA|
EXT4_FEATURE_INCOMPAT_ENCRYPT |
diff --git a/misc/tune2fs.c b/misc/tune2fs.c
index 3db57632c..c5a40c5c9 100644
--- a/misc/tune2fs.c
+++ b/misc/tune2fs.c
@@ -192,6 +192,7 @@ static __u32 ok_features[3] = {
EXT4_FEATURE_INCOMPAT_FLEX_BG |
EXT4_FEATURE_INCOMPAT_EA_INODE|
EXT4_FEATURE_INCOMPAT_MMP |
+ EXT4_FEATURE_INCOMPAT_DIRDATA |
EXT4_FEATURE_INCOMPAT_64BIT |
EXT4_FEATURE_INCOMPAT_ENCRYPT |
EXT4_FEATURE_INCOMPAT_CSUM_SEED |
@@ -222,6 +223,7 @@ static __u32 clear_ok_features[3] = {
EXT2_FEATURE_INCOMPAT_FILETYPE |
EXT4_FEATURE_INCOMPAT_FLEX_BG |
EXT4_FEATURE_INCOMPAT_MMP |
+ EXT4_FEATURE_INCOMPAT_DIRDATA |
EXT4_FEATURE_INCOMPAT_64BIT |
EXT4_FEATURE_INCOMPAT_CSUM_SEED |
EXT4_FEATURE_INCOMPAT_CASEFOLD,
--
2.43.7
^ permalink raw reply related
* [PATCH 08/13] debugfs: add dirdata display support
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Enhance debugfs debug utility with dirdata display capabilities. This allows
users to inspect Lustre File IDentifier (LUFID) and checksum hash (CFHASH)
data embedded in directory entries.
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
debugfs/debugfs.8.in | 7 ++++-
debugfs/ls.c | 63 +++++++++++++++++++++++++++++++++++++++++---
debugfs/ncheck.c | 3 +++
3 files changed, 69 insertions(+), 4 deletions(-)
diff --git a/debugfs/debugfs.8.in b/debugfs/debugfs.8.in
index 08f41fdfa..5a5dd32b0 100644
--- a/debugfs/debugfs.8.in
+++ b/debugfs/debugfs.8.in
@@ -575,7 +575,7 @@ Instead, it will stop only when the entire log is printed or after
.I num_trans
transactions.
.TP
-.BI ls " [\-l] [\-c] [\-d] [\-p] [\-r] filespec"
+.BI ls " [\-l] [\-c] [\-d] [\-p] [\-r] [\-D] filespec"
Print a listing of the files in the directory
.IR filespec .
The
@@ -595,6 +595,11 @@ non-printing characters at the end of filenames.
The
.I \-r
flag will force the printing of the filename, even if it is encrypted.
+The
+.I \-D
+flag will print the extra data found inside each entry when the
+.I \-l
+flag is used.
.TP
.BI list_deleted_inodes " [limit]"
List deleted inodes, optionally limited to those deleted within
diff --git a/debugfs/ls.c b/debugfs/ls.c
index 613ad7380..d225982cb 100644
--- a/debugfs/ls.c
+++ b/debugfs/ls.c
@@ -24,6 +24,7 @@ extern char *optarg;
#endif
#include "debugfs.h"
+#include "ext2fs/lfsck.h"
/*
* list directory
@@ -32,6 +33,7 @@ extern char *optarg;
#define LONG_OPT 0x0001
#define PARSE_OPT 0x0002
#define RAW_OPT 0x0004
+#define DIRDATA_OPT 0x0008
#define ENCRYPT_OPT 0x8000
struct list_dir_struct {
@@ -44,6 +46,55 @@ struct list_dir_struct {
static const char *monstr[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+static void list_dirdata(struct list_dir_struct *ls,
+ struct ext2_dir_entry *dirent)
+{
+ unsigned char *data;
+ int dlen;
+ __u8 dirdata_mask;
+ __u8 file_type = dirent->name_len >> 8;
+
+ data = (unsigned char *)dirent->name +
+ (dirent->name_len & EXT2_NAME_LEN) + 1;
+
+ for (dirdata_mask = EXT2_FT_MASK + 1;
+ dirdata_mask != 0; dirdata_mask <<= 1) {
+ if ((dirdata_mask & file_type) == 0)
+ continue;
+
+ dlen = data[0];
+
+ if (dirdata_mask == EXT2_DIRENT_LUFID) {
+ struct lu_fid fid;
+ int offset = 0;
+ fprintf(ls->f, " fid=");
+ while (offset < (dlen - 1)) {
+ memcpy(&fid, data + offset + 1, sizeof(fid));
+ fid_be_to_cpu(&fid, &fid);
+ offset += sizeof(fid);
+ fprintf(ls->f, DFID, PFID(&fid));
+ if (offset < (dlen - 1))
+ fprintf(ls->f, ",");
+ }
+ } else if (dirdata_mask == EXT2_DIRENT_CFHASH) {
+ struct ext4_dirent_hash hash;
+
+ memcpy(&hash, data, sizeof(hash));
+ hash_le_to_cpu(&hash, &hash);
+
+ fprintf(ls->f, "hash: 0x%08x, minor_hash: 0x%08x",
+ hash.dh_hash.hash, hash.dh_hash.minor_hash);
+ } else {
+ int i;
+
+ for (i = 1; i < dlen; i++)
+ fprintf(ls->f, "%02x", data[i]);
+ }
+
+ data += dlen;
+ }
+}
+
static int print_filename(FILE *f, struct ext2_dir_entry *dirent, int options)
{
unsigned char ch;
@@ -146,7 +197,10 @@ static int list_dir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)),
inode_uid(inode), inode_gid(inode));
fprintf(ls->f, "%5llu",
(unsigned long long) EXT2_I_SIZE(&inode));
- fprintf(ls->f, " %s ", datestr);
+ fprintf(ls->f, " %s", datestr);
+ if ((ls->options & DIRDATA_OPT) != 0)
+ list_dirdata(ls, dirent);
+ fprintf(ls->f, " ");
print_filename(ls->f, dirent, options);
fputc('\n', ls->f);
} else {
@@ -195,7 +249,7 @@ void do_list_dir(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
return;
reset_getopt();
- while ((c = getopt (argc, argv, "cdlpr")) != EOF) {
+ while ((c = getopt(argc, argv, "cdDlpr")) != EOF) {
switch (c) {
case 'c':
flags |= DIRENT_FLAG_INCLUDE_CSUM;
@@ -203,6 +257,9 @@ void do_list_dir(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
case 'l':
ls.options |= LONG_OPT;
break;
+ case 'D':
+ ls.options |= DIRDATA_OPT;
+ break;
case 'd':
flags |= DIRENT_FLAG_INCLUDE_REMOVED;
break;
@@ -219,7 +276,7 @@ void do_list_dir(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
if (argc > optind+1) {
print_usage:
- com_err(0, 0, "Usage: ls [-c] [-d] [-l] [-p] [-r] file");
+ com_err(0, 0, "Usage: ls [-c] [-d] [-D] [-l] [-p] [-r] file");
return;
}
diff --git a/debugfs/ncheck.c b/debugfs/ncheck.c
index 1410e7c6d..03d1e49cf 100644
--- a/debugfs/ncheck.c
+++ b/debugfs/ncheck.c
@@ -51,6 +51,9 @@ static int ncheck_proc(struct ext2_dir_entry *dirent,
iw->position++;
if (iw->position <= 2)
return 0;
+ if (current_fs->super->s_feature_incompat &
+ EXT4_FEATURE_INCOMPAT_DIRDATA)
+ filetype &= EXT2_FT_MASK;
for (i=0; i < iw->num_inodes; i++) {
if (iw->iarray[i] == dirent->inode) {
if (!iw->parent && !iw->get_pathname_failed) {
--
2.43.7
^ permalink raw reply related
* [PATCH 07/13] e2fsck: directory rehashing with dirdata support
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Etienne AUJAMES, Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Implement complex directory optimization and rehashing with proper dirdata
handling. This prevents corruption when renaming duplicate entries with name
expansion.
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Etienne AUJAMES <eaujames@ddn.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
e2fsck/rehash.c | 235 ++++++++++++++++++++++++++++++++----------------
1 file changed, 156 insertions(+), 79 deletions(-)
diff --git a/e2fsck/rehash.c b/e2fsck/rehash.c
index 4847d172e..75339a67e 100644
--- a/e2fsck/rehash.c
+++ b/e2fsck/rehash.c
@@ -53,6 +53,9 @@
#include "problem.h"
#include "support/sort_r.h"
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
/* Schedule a dir to be rebuilt during pass 3A. */
void e2fsck_rehash_dir_later(e2fsck_t ctx, ext2_ino_t ino)
{
@@ -86,6 +89,8 @@ struct fill_dir_struct {
int compress;
ext2_ino_t parent;
ext2_ino_t dir;
+ struct ext2_dir_entry *dot_de;
+ struct ext2_dir_entry *dotdot_de;
};
struct hash_entry {
@@ -187,11 +192,14 @@ static int fill_dir_block(ext2_filsys fs,
return BLOCK_ABORT;
}
if (!fd->compress && (name_len == 1) &&
- (dirent->name[0] == '.'))
+ (dirent->name[0] == '.')) {
+ fd->dot_de = dirent;
continue;
+ }
if (!fd->compress && (name_len == 2) &&
(dirent->name[0] == '.') && (dirent->name[1] == '.')) {
fd->parent = dirent->inode;
+ fd->dotdot_de = dirent;
continue;
}
if (fd->num_array >= fd->max_array) {
@@ -209,7 +217,7 @@ static int fill_dir_block(ext2_filsys fs,
}
ent = fd->harray + fd->num_array++;
ent->dir = dirent;
- fd->dir_size += ext2fs_dir_rec_len(name_len, extended);
+ fd->dir_size += ext2fs_dirdata_rec_len(dirent, extended);
ent->ino = dirent->inode;
if (extended) {
ent->hash = EXT2_DIRENT_HASH(dirent);
@@ -390,66 +398,128 @@ static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir,
return 0;
}
+static void increment_name(char *str, int len)
+{
+ int i;
+
+ for (i = len - 1; i >= 0; i--) {
+ switch(str[i]) {
+ case '~':
+ str[i] = '1';
+ if (i > 0 && len > 2)
+ str[i-1] = '~';
+ break;
+ case '9':
+ if (i > 1) {
+ str[i] = '0';
+ continue;
+ }
+ str[i] = 'a';
+ break;
+ case 'z':
+ str[i] = 'A';
+ break;
+ case 'Z':
+ str[i] = '0';
+ continue;
+ default:
+ if (!isalnum(str[i]))
+ str[i] = '~';
+ else
+ str[i]++;
+ }
+ break;
+ }
+}
+
/*
* This function is used to make a unique filename. We do this by
* appending ~0, and then incrementing the number. However, we cannot
* expand the length of the filename beyond the padding available in
* the directory entry.
+ * e.g:
+ * - test (max: 6) -> test~0
+ * - test~9 (max: 6) -> tes~10
+ * - test (max: 4) -> te~0
+ * - te (max: 3) -> t~0
+ * - t (max: 2) -> t~
+ * - t~ (max: 2) -> t1
+ * - t9 (max: 2) -> ta
+ * - tZ (max: 2) -> u0
+ * - t (max: 1) -> u
*/
-static void mutate_name(char *str, unsigned int *len)
+static void mutate_name(char *str, int *len, int max_len)
{
int i;
- unsigned int l = *len;
+ int l = *len;
/*
* First check to see if it looks the name has been mutated
* already
*/
+ max_len = max(max_len, l);
for (i = l-1; i > 0; i--) {
- if (!isdigit(str[i]))
+ if (!isalnum(str[i]))
break;
}
- if ((i == (int)l - 1) || (str[i] != '~')) {
- if (((l-1) & 3) < 2)
- l += 2;
- else
- l = (l+3) & ~3;
- if (l > 255)
- l = 255;
+
+ if ((i != l-1 && str[i] == '~') ||
+ (max_len <= 2 && max_len == l)) {
+ increment_name(str, l);
+ return;
+ }
+
+ /* Add the first suffix: "~0" */
+ l += min(2, max_len - l);
+ if (l > 2) {
str[l-2] = '~';
str[l-1] = '0';
- *len = l;
- return;
+ } else {
+ str[l-1] = '~';
}
- for (i = l-1; i >= 0; i--) {
- if (isdigit(str[i])) {
- if (str[i] == '9')
- str[i] = '0';
- else {
- str[i]++;
- return;
- }
- continue;
- }
- if (i == 1) {
- if (str[0] == 'z')
- str[0] = 'A';
- else if (str[0] == 'Z') {
- str[0] = '~';
- str[1] = '0';
- } else
- str[0]++;
- } else if (i > 0) {
- str[i] = '1';
- str[i-1] = '~';
- } else {
- if (str[0] == '~')
- str[0] = 'a';
- else
- str[0]++;
+
+ *len = l;
+}
+
+
+static errcode_t rename_dentry(struct ext2_dir_entry *de, char *new_name,
+ unsigned int new_len)
+{
+ int dirdata_size = ext2_get_dirdata_size(de);
+ int diff = new_len - ext2fs_dirent_name_len(de);
+ int new_dirdata_off = offsetof(typeof(*de), name) + new_len;
+ void *mv_src, *mv_dst;
+
+ if (diff <= 0 || !dirdata_size) {
+ memcpy(de->name, new_name, new_len);
+ ext2fs_dirent_set_name_len(de, new_len);
+ }
+
+ if (!dirdata_size || !diff)
+ return 0;
+
+ /* move dirdata if needed */
+ if (diff > 0 ) {
+ int rec_len = EXT2_DIRENT_REC_LEN(de);
+
+ /* this should nerver happen (see mutate_name()) */
+ if (new_dirdata_off + dirdata_size > rec_len) {
+ com_err("rename_dentry", ERANGE,
+ _("failed to rename %u"), de->inode);
+ return ERANGE;
}
- break;
}
+
+ mv_dst = (void *)de + new_dirdata_off;
+ mv_src = mv_dst - diff;
+ memmove(mv_dst, mv_src, dirdata_size);
+
+ if (diff > 0) {
+ memcpy(de->name, new_name, new_len);
+ ext2fs_dirent_set_name_len(de, new_len);
+ }
+
+ return 0;
}
static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
@@ -462,7 +532,7 @@ static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
blk_t i, j;
int fixed = 0;
char new_name[256];
- unsigned int new_len;
+ int new_len, max_len;
int hash_alg;
int hash_flags = fd->inode->i_flags & EXT4_CASEFOLD_FL;
@@ -507,7 +577,9 @@ static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
continue;
}
memcpy(new_name, ent->dir->name, new_len);
- mutate_name(new_name, &new_len);
+ max_len = min(EXT2_NAME_LEN,
+ new_len + ext2fs_dir_rec_padding(ent->dir));
+ mutate_name(new_name, &new_len, max_len);
for (j=0; j < fd->num_array; j++) {
if ((i==j) ||
!same_name(cmp_ctx, new_name, new_len,
@@ -515,15 +587,14 @@ static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
ext2fs_dirent_name_len(fd->harray[j].dir))) {
continue;
}
- mutate_name(new_name, &new_len);
+ mutate_name(new_name, &new_len, max_len);
j = -1;
}
new_name[new_len] = 0;
pctx.str = new_name;
- if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) {
- memcpy(ent->dir->name, new_name, new_len);
- ext2fs_dirent_set_name_len(ent->dir, new_len);
+ if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx) &&
+ !rename_dentry(ent->dir, new_name, new_len)) {
ext2fs_dirhash2(hash_alg, new_name, new_len,
fs->encoding, hash_flags,
fs->super->s_hash_seed,
@@ -587,8 +658,7 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
ent = fd->harray + i;
if (ent->dir->inode == 0)
continue;
- rec_len = ext2fs_dir_rec_len(ext2fs_dirent_name_len(ent->dir),
- hash_in_entry);
+ rec_len = ext2fs_dirdata_rec_len(ent->dir, hash_in_entry);
if (rec_len > left) {
if (left) {
left += prev_rec_len;
@@ -623,8 +693,7 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
if (retval)
return retval;
prev_rec_len = rec_len;
- memcpy(dirent->name, ent->dir->name,
- ext2fs_dirent_name_len(dirent));
+ memcpy(dirent->name, ent->dir->name, rec_len);
if (hash_in_entry) {
EXT2_DIRENT_HASHES(dirent)->hash = ext2fs_cpu_to_le32(ent->hash);
EXT2_DIRENT_HASHES(dirent)->minor_hash =
@@ -655,47 +724,52 @@ static errcode_t copy_dir_entries(e2fsck_t ctx,
static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf,
ext2_ino_t ino, ext2_ino_t parent,
+ struct ext2_dir_entry *dot_de,
+ struct ext2_dir_entry *dotdot_de,
struct ext2_inode *inode)
{
- struct ext2_dir_entry *dir;
- struct ext2_dx_root_info *root;
+ struct ext2_dir_entry *dirent;
+ struct ext2_dx_root_info *root;
struct ext2_dx_countlimit *limits;
- int filetype = 0;
int csum_size = 0;
-
- if (ext2fs_has_feature_filetype(fs->super))
- filetype = EXT2_FT_DIR;
+ int offset;
+ int rec_len;
memset(buf, 0, fs->blocksize);
- dir = (struct ext2_dir_entry *) buf;
- dir->inode = ino;
- dir->name[0] = '.';
- ext2fs_dirent_set_name_len(dir, 1);
- ext2fs_dirent_set_file_type(dir, filetype);
- dir->rec_len = 12;
- dir = (struct ext2_dir_entry *) (buf + 12);
- dir->inode = parent;
- dir->name[0] = '.';
- dir->name[1] = '.';
- ext2fs_dirent_set_name_len(dir, 2);
- ext2fs_dirent_set_file_type(dir, filetype);
- dir->rec_len = fs->blocksize - 12;
-
- root = (struct ext2_dx_root_info *) (buf+24);
+ dirent = (struct ext2_dir_entry *) buf;
+ dirent->inode = ino;
+
+ dirent->name_len = dot_de->name_len;
+ offset = rec_len = dirent->rec_len = dot_de->rec_len;
+ memcpy(dirent->name, dot_de->name, rec_len);
+
+ dirent = EXT2_NEXT_DIRENT(dirent);
+ /* set to jump over the index block */
+
+ dirent->inode = parent;
+
+ dirent->name_len = dotdot_de->name_len;
+ dirent->rec_len = fs->blocksize - rec_len;
+ rec_len = EXT2_DIRENT_REC_LEN(dotdot_de);
+ memcpy(dirent->name, dotdot_de->name, rec_len);
+ offset += rec_len;
+
+ root = (struct ext2_dx_root_info *)(buf + offset);
root->reserved_zero = 0;
if (ext4_hash_in_dirent(inode))
root->hash_version = EXT2_HASH_SIPHASH;
else
root->hash_version = fs->super->s_def_hash_version;
- root->info_length = 8;
+ root->info_length = sizeof(*root);
root->indirect_levels = 0;
root->unused_flags = 0;
+ offset += root->info_length;
if (ext2fs_has_feature_metadata_csum(fs->super))
csum_size = sizeof(struct ext2_dx_tail);
- limits = (struct ext2_dx_countlimit *) (buf+32);
- limits->limit = (fs->blocksize - (32 + csum_size)) /
+ limits = (struct ext2_dx_countlimit *) (buf + offset);
+ limits->limit = (fs->blocksize - (offset + csum_size)) /
sizeof(struct ext2_dx_entry);
limits->count = 0;
@@ -773,6 +847,8 @@ static errcode_t calculate_tree(ext2_filsys fs,
struct out_dir *outdir,
ext2_ino_t ino,
ext2_ino_t parent,
+ struct ext2_dir_entry *dot_de,
+ struct ext2_dir_entry *dotdot_de,
struct ext2_inode *inode)
{
struct ext2_dx_root_info *root_info;
@@ -782,7 +858,9 @@ static errcode_t calculate_tree(ext2_filsys fs,
int i, c1, c2, c3, nblks;
int limit_offset, int_offset, root_offset;
- root_info = set_root_node(fs, outdir->buf, ino, parent, inode);
+ root_info = set_root_node(fs, outdir->buf, ino, parent, dot_de,
+ dotdot_de, inode);
+
root_offset = limit_offset = ((char *) root_info - outdir->buf) +
root_info->info_length;
root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset);
@@ -1087,11 +1165,10 @@ resort:
if (retval)
goto errout;
- free(dir_buf); dir_buf = 0;
-
if (!fd.compress) {
/* Calculate the interior nodes */
- retval = calculate_tree(fs, &outdir, ino, fd.parent, fd.inode);
+ retval = calculate_tree(fs, &outdir, ino, fd.parent,
+ fd.dot_de, fd.dotdot_de, fd.inode);
if (retval)
goto errout;
}
--
2.43.7
^ permalink raw reply related
* [PATCH 06/13] e2fsck: dirdata message formatting and pass3 support
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Add FID extraction and error message formatting for dirdata, plus pass3
support for proper error reporting with Lustre-specific metadata.
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
e2fsck/message.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++-
e2fsck/pass3.c | 7 ++++++
2 files changed, 61 insertions(+), 1 deletion(-)
diff --git a/e2fsck/message.c b/e2fsck/message.c
index 9c42b13fb..193d887ec 100644
--- a/e2fsck/message.c
+++ b/e2fsck/message.c
@@ -99,6 +99,7 @@
#include "e2fsck.h"
#include "problem.h"
+#include "ext2fs/lfsck.h"
#ifdef __GNUC__
#define _INLINE_ __inline__
@@ -346,6 +347,41 @@ static _INLINE_ void expand_inode_expression(FILE *f, ext2_filsys fs, char ch,
}
}
+int get_dirent_fid(struct ext2_dir_entry *dirent, struct lu_fid **fids)
+{
+ unsigned char *data = (unsigned char *)dirent->name +
+ (dirent->name_len & EXT2_NAME_LEN) + 1;
+ __u8 file_type = dirent->name_len >> 8;
+ __u8 dirdata_mask;
+ int retlen = 0;
+
+ for (dirdata_mask = EXT2_FT_MASK + 1;
+ dirdata_mask != 0; dirdata_mask <<= 1) {
+ int dlen;
+
+ if ((dirdata_mask & file_type) == 0)
+ continue;
+
+ dlen = data[0];
+ if (dirdata_mask == EXT2_DIRENT_LUFID) {
+ struct lu_fid *fid;
+ int len = dlen;
+
+ *fids = (struct lu_fid *)(data + 1);
+ for (fid = *fids; len >= sizeof(*fid); fid++,
+ len -= sizeof(*fid)) {
+ memcpy(fid, data + 1, sizeof(*fid));
+ fid_be_to_cpu(fid, fid);
+ }
+ retlen = dlen;
+ break;
+ }
+ data += dlen;
+ }
+
+ return retlen;
+}
+
/*
* This function expands '%dX' expressions
*/
@@ -361,9 +397,26 @@ static _INLINE_ void expand_dirent_expression(FILE *f, ext2_filsys fs, char ch,
dirent = ctx->dirent;
switch (ch) {
- case 'i':
+ case 'i': {
+ struct lu_fid *fids;
+ int i;
+ int fids_len;
+
fprintf(f, "%u", dirent->inode);
+
+ fids_len = get_dirent_fid(dirent, &fids);
+ if (fids_len > sizeof(*fids))
+ fprintf(f, " fid=");
+ while (fids_len > sizeof(*fids)) {
+ fprintf(f, DFID, PFID(fids));
+ fids++;
+ fids_len -= sizeof(*fids);
+ if (fids_len >= sizeof(*fids))
+ fprintf(f, ",");
+ }
+
break;
+ }
case 'n':
len = ext2fs_dirent_name_len(dirent);
if ((ext2fs_get_rec_len(fs, dirent, &rec_len) == 0) &&
diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c
index 56798b1bc..343609832 100644
--- a/e2fsck/pass3.c
+++ b/e2fsck/pass3.c
@@ -706,6 +706,7 @@ static int fix_dotdot_proc(struct ext2_dir_entry *dirent,
struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data;
errcode_t retval;
struct problem_context pctx;
+ __u16 dirdata = 0;
if (ext2fs_dirent_name_len(dirent) != 2)
return 0;
@@ -725,11 +726,17 @@ static int fix_dotdot_proc(struct ext2_dir_entry *dirent,
fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx);
}
dirent->inode = fp->parent;
+
+ dirdata = dirent->name_len & ((__u16)~EXT2_FT_MASK << 8);
+
if (ext2fs_has_feature_filetype(fp->ctx->fs->super))
ext2fs_dirent_set_file_type(dirent, EXT2_FT_DIR);
else
ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN);
+ if (ext2fs_has_feature_dirdata(fp->ctx->fs->super))
+ dirent->name_len |= dirdata;
+
fp->done++;
return DIRENT_ABORT | DIRENT_CHANGED;
}
--
2.43.7
^ permalink raw reply related
* [PATCH 05/13] e2fsck: pass2 dirdata validation and repair
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Implement comprehensive validation and repair logic for dirdata fields in
pass 2 of e2fsck. This ensures directory entries with embedded Lustre FID
data are properly checked and corrected.
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
e2fsck/pass2.c | 130 ++++++++++++++++++++++++++++++++++++++++++-----
e2fsck/problem.c | 5 ++
e2fsck/problem.h | 3 ++
3 files changed, 125 insertions(+), 13 deletions(-)
diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index cf1678c85..938942a80 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -395,13 +395,103 @@ static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b)
return (int) (db_a->blockcnt - db_b->blockcnt);
}
+void ext2_fix_dirent_dirdata(struct ext2_dir_entry *de)
+{
+ __u16 file_type = de->name_len & (EXT2_FT_MASK << 8);
+ __u8 de_flags = (de->name_len >> 8) & ~EXT2_FT_MASK;
+ __u8 name_len = de->name_len & EXT2_NAME_LEN;
+ __u8 new_flag = 0;
+ int i;
+
+ for (i = 0; i < 4; i++) {
+ __u8 flags = new_flag | (1 << i) << 4;
+
+ /* new_flag is accumulating flags that are set in de_flags
+ * and still fit inside rec_len. ext2_get_dirent_dirdata_size()
+ * returns the size of all the dirdata entries in flags, and
+ * chops off any that are beyond rec_len.
+ */
+ if ((de_flags & flags) == flags) {
+ int dirdatalen = ext2_get_dirdata_field_size(de,flags);
+ int rlen = EXT2_DIR_NAME_LEN(name_len + 1 +
+ dirdatalen);
+
+ if (rlen > de->rec_len)
+ break;
+
+ new_flag |= flags;
+ }
+ }
+
+ de->name_len = name_len | file_type | (new_flag << 8);
+}
+
+/*
+ * check for dirent data in ext4 dirent.
+ * return 0 if dirent data is ok.
+ * return 1 if dirent data does not exist.
+ * return 2 if dirent was modified due to error.
+ */
+int e2fsck_check_dirent_data(e2fsck_t ctx, struct ext2_dir_entry *de,
+ unsigned int offset, struct problem_context *pctx)
+{
+ if (!(ctx->fs->super->s_feature_incompat &
+ EXT4_FEATURE_INCOMPAT_DIRDATA)) {
+ if ((de->name_len >> 8) & ~EXT2_FT_MASK) {
+ /* clear dirent extra data flags. */
+ if (fix_problem(ctx, PR_2_CLEAR_DIRDATA, pctx)) {
+ de->name_len &= (EXT2_FT_MASK << 8) |
+ EXT2_NAME_LEN;
+ return 2;
+ }
+ }
+ return 1;
+ }
+
+ if (!((de->name_len >> 8) & ~EXT2_FT_MASK))
+ return 1;
+
+ if (de->rec_len >= EXT2_DIRENT_REC_LEN(de) ||
+ de->rec_len + offset == EXT2_BLOCK_SIZE(ctx->fs->super)) {
+ int lufid_size, cshash_size;
+
+ lufid_size = ext2_get_dirdata_field_size(de,
+ EXT2_DIRENT_LUFID);
+
+ if (lufid_size != 0 && lufid_size %
+ EXT2_DIRENT_LUFID_SIZE != 1) /* size byte */
+ goto fix;
+
+ cshash_size = ext2_get_dirdata_field_size(de,
+ EXT2_DIRENT_CFHASH);
+
+ if (cshash_size != 0 && cshash_size !=
+ sizeof(struct ext2_dir_entry_hash) + 1) /* size byte */
+ goto fix;
+
+ return 0;
+ }
+
+fix:
+ /* just clear dirent data flags for now */
+ if (fix_problem(ctx, PR_2_CLEAR_DIRDATA, pctx)) {
+ ext2_fix_dirent_dirdata(de);
+ if (ext2_get_dirdata_field_size(de,
+ EXT2_DIRENT_LUFID) %
+ EXT2_DIRENT_LUFID_SIZE != 1)
+ de->name_len &= ~(EXT2_DIRENT_LUFID << 8);
+
+ return 2;
+ }
+ return 1;
+}
/*
* Make sure the first entry in the directory is '.', and that the
* directory entry is sane.
*/
static int check_dot(e2fsck_t ctx,
- struct ext2_dir_entry *dirent,
+ struct ext2_dir_entry *dirent, unsigned int offset,
ext2_ino_t ino, struct problem_context *pctx)
{
struct ext2_dir_entry *nextdir;
@@ -410,6 +500,7 @@ static int check_dot(e2fsck_t ctx,
int created = 0;
problem_t problem = 0;
int ftype = EXT2_FT_DIR;
+ int dir_data_error;
if (!dirent->inode)
problem = PR_2_MISSING_DOT;
@@ -419,12 +510,14 @@ static int check_dot(e2fsck_t ctx,
else if (dirent->name[1] != '\0')
problem = PR_2_DOT_NULL_TERM;
+ dir_data_error = e2fsck_check_dirent_data(ctx, dirent, offset, pctx);
+
(void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
if (problem) {
if (!ext2fs_has_feature_filetype(ctx->fs->super))
ftype = EXT2_FT_UNKNOWN;
if (fix_problem(ctx, problem, pctx)) {
- if (rec_len < 12)
+ if (rec_len < 12 && dir_data_error)
rec_len = dirent->rec_len = 12;
dirent->inode = ino;
ext2fs_dirent_set_name_len(dirent, 1);
@@ -443,7 +536,7 @@ static int check_dot(e2fsck_t ctx,
}
if (rec_len > 12) {
new_len = rec_len - 12;
- if (new_len > 12) {
+ if (new_len > 12 && dir_data_error) {
if (created ||
fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) {
nextdir = (struct ext2_dir_entry *)
@@ -480,12 +573,13 @@ static int check_dot(e2fsck_t ctx,
* here; this gets done in pass 3.
*/
static int check_dotdot(e2fsck_t ctx,
- struct ext2_dir_entry *dirent,
+ struct ext2_dir_entry *dirent, unsigned int offset,
ext2_ino_t ino, struct problem_context *pctx)
{
problem_t problem = 0;
unsigned int rec_len;
int ftype = EXT2_FT_DIR;
+ int dir_data_error;
if (!dirent->inode)
problem = PR_2_MISSING_DOT_DOT;
@@ -496,12 +590,14 @@ static int check_dotdot(e2fsck_t ctx,
else if (dirent->name[2] != '\0')
problem = PR_2_DOT_DOT_NULL_TERM;
+ dir_data_error = e2fsck_check_dirent_data(ctx, dirent, offset, pctx);
+
(void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len);
if (problem) {
if (!ext2fs_has_feature_filetype(ctx->fs->super))
ftype = EXT2_FT_UNKNOWN;
if (fix_problem(ctx, problem, pctx)) {
- if (rec_len < 12)
+ if (rec_len < 12 && dir_data_error)
dirent->rec_len = 12;
/*
* Note: we don't have the parent inode just
@@ -597,6 +693,12 @@ static _INLINE_ int check_filetype(e2fsck_t ctx,
int filetype = ext2fs_dirent_file_type(dirent);
int should_be = EXT2_FT_UNKNOWN;
struct ext2_inode inode;
+ __u8 dirdata = 0;
+
+ if (ext2fs_has_feature_dirdata(ctx->fs->super)) {
+ dirdata = filetype & ~EXT2_FT_MASK;
+ filetype = filetype & EXT2_FT_MASK;
+ }
if (!ext2fs_has_feature_filetype(ctx->fs->super)) {
if (filetype == 0 ||
@@ -627,8 +729,7 @@ static _INLINE_ int check_filetype(e2fsck_t ctx,
if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE,
pctx) == 0)
return 0;
-
- ext2fs_dirent_set_file_type(dirent, should_be);
+ ext2fs_dirent_set_file_type(dirent, should_be | dirdata);
return 1;
}
@@ -660,8 +761,8 @@ static void parse_int_node(ext2_filsys fs,
printf("\t Indirect levels: %u\n", root->indirect_levels);
printf("\t Flags: %x\n", root->unused_flags);
#endif
-
- ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length);
+ ent = (struct ext2_dx_entry *)((char *)root +
+ root->info_length);
if (failed_csum &&
(e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) ||
@@ -669,7 +770,7 @@ static void parse_int_node(ext2_filsys fs,
&cd->pctx)))
goto clear_and_exit;
} else {
- ent = (struct ext2_dx_entry *) (block_buf+8);
+ ent = (struct ext2_dx_entry *)(block_buf + 8);
if (failed_csum &&
(e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) ||
@@ -851,7 +952,6 @@ static void salvage_directory(ext2_filsys fs,
}
}
-#define NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len))
static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf)
{
struct ext2_dir_entry *d;
@@ -1427,10 +1527,10 @@ skip_checksum:
}
if (dot_state == 0) {
- if (check_dot(ctx, dirent, ino, &cd->pctx))
+ if (check_dot(ctx, dirent, offset, ino, &cd->pctx))
dir_modified++;
} else if (dot_state == 1) {
- ret = check_dotdot(ctx, dirent, ino, &cd->pctx);
+ ret = check_dotdot(ctx, dirent, offset, ino, &cd->pctx);
if (ret < 0)
goto abort_free_dict;
if (ret)
@@ -1446,6 +1546,10 @@ skip_checksum:
if (!dirent->inode)
goto next;
+ ret = e2fsck_check_dirent_data(ctx, dirent, offset, &cd->pctx);
+ if (ret == 2)
+ dir_modified++;
+
/*
* Make sure the inode listed is a legal one.
*/
diff --git a/e2fsck/problem.c b/e2fsck/problem.c
index e433281fa..afa3d517a 100644
--- a/e2fsck/problem.c
+++ b/e2fsck/problem.c
@@ -1875,6 +1875,11 @@ static struct e2fsck_problem problem_table[] = {
N_("@E references EA @i %Di.\n"),
PROMPT_CLEAR, 0, 0, 0, 0 },
+ /* Directory entry dirdata length set incorrectly */
+ { PR_2_CLEAR_DIRDATA,
+ N_("@E dirdata length set incorrectly.\n"),
+ PROMPT_CLEAR, PR_PREEN_OK },
+
/* Pass 3 errors */
/* Pass 3: Checking directory connectivity */
diff --git a/e2fsck/problem.h b/e2fsck/problem.h
index ef15b8c84..1ef519908 100644
--- a/e2fsck/problem.h
+++ b/e2fsck/problem.h
@@ -1070,6 +1070,9 @@ struct problem_context {
/* EA inode referenced from directory */
#define PR_2_EA_INODE_DIR_LINK 0x020055
+/* Entry dirdata length set incorrectly */
+#define PR_2_CLEAR_DIRDATA 0x020057
+
/*
* Pass 3 errors
*/
--
2.43.7
^ permalink raw reply related
* [PATCH 04/13] libext2fs: add helper for dx_root_info lookup
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4; +Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Add dirdata support infrastructure in the new lfsck.h header, with
data structures (lu_fid, ext4_dirent_data_header, ext4_dirent_hash)
related to dirdata fields.
Also changes to ext2_fs.h and ext2fs.h to support INCOMPAT_DIRDATA.
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
debugfs/htree.c | 2 +-
e2fsck/pass1.c | 2 +-
e2fsck/pass2.c | 7 +++----
lib/ext2fs/ext2fs.h | 19 +++++++++++++++++++
4 files changed, 24 insertions(+), 6 deletions(-)
diff --git a/debugfs/htree.c b/debugfs/htree.c
index 4ea8f30b3..efb858271 100644
--- a/debugfs/htree.c
+++ b/debugfs/htree.c
@@ -298,7 +298,7 @@ void do_htree_dump(int argc, ss_argv_t argv, int sci_idx EXT2FS_ATTR((unused)),
goto errout;
}
- rootnode = (struct ext2_dx_root_info *) (buf + 24);
+ rootnode = ext2fs_get_dx_root_info(current_fs, buf);
fprintf(pager, "Root node dump:\n");
fprintf(pager, "\t Reserved zero: %u\n", rootnode->reserved_zero);
diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 39d1255f9..12925ce2f 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -2801,7 +2801,7 @@ static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
return 1;
/* XXX should check that beginning matches a directory */
- root = (struct ext2_dx_root_info *) (block_buf + 24);
+ root = ext2fs_get_dx_root_info(fs, block_buf);
if ((root->reserved_zero || root->info_length < 8) &&
fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index 319e7e0e3..cf1678c85 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -650,7 +650,7 @@ static void parse_int_node(ext2_filsys fs,
int csum_size = 0;
if (db->blockcnt == 0) {
- root = (struct ext2_dx_root_info *) (block_buf + 24);
+ root = ext2fs_get_dx_root_info(fs, block_buf);
#ifdef DX_DEBUG
printf("Root node dump:\n");
@@ -677,8 +677,7 @@ static void parse_int_node(ext2_filsys fs,
&cd->pctx)))
goto clear_and_exit;
}
-
- limit = (struct ext2_dx_countlimit *) ent;
+ limit = (struct ext2_dx_countlimit *)ent;
#ifdef DX_DEBUG
printf("Number of entries (count): %d\n",
@@ -1236,7 +1235,7 @@ inline_read_fail:
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
limit = (struct ext2_dx_countlimit *) (buf+8);
if (db->blockcnt == 0) {
- root = (struct ext2_dx_root_info *) (buf + 24);
+ root = ext2fs_get_dx_root_info(fs, buf);
dx_db->type = DX_DIRBLOCK_ROOT;
dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index 91d269865..cf12716e3 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -2262,6 +2262,25 @@ _INLINE_ int ext2fs_htree_intnode_maxrecs(ext2_filsys fs, int blocks)
sizeof(struct ext2_dx_entry));
}
+_INLINE_ struct ext2_dx_root_info *ext2fs_get_dx_root_info(ext2_filsys fs,
+ char *buf)
+{
+ struct ext2_dir_entry *de = (struct ext2_dir_entry *)buf;
+
+ if (!(fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_DIRDATA))
+ return (struct ext2_dx_root_info *)(buf +
+ EXT2_DIR_NAME_LEN(1) +
+ EXT2_DIR_NAME_LEN(2));
+
+ /* get dotdot first */
+ de = (struct ext2_dir_entry *)((char *)de + de->rec_len);
+
+ /* dx root info is after dotdot entry */
+ de = EXT2_NEXT_DIRENT(de);
+
+ return (struct ext2_dx_root_info *)de;
+}
+
/*
* log base 2, rounded down
*/
--
2.43.7
^ permalink raw reply related
* [PATCH 03/13] ext2fs: dirdata infrastructure and core functions
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Add dirdata support infrastructure in the new lfsck.h header, with
data structures (lu_fid, ext4_dirent_data_header, ext4_dirent_hash)
related to dirdata fields.
Define dirdata feature add some other helper functions.
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
lib/ext2fs/ext2_fs.h | 30 +++++++++++++++++++++++++++-
lib/ext2fs/ext2fs.h | 3 ++-
lib/ext2fs/lfsck.h | 47 ++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 78 insertions(+), 2 deletions(-)
diff --git a/lib/ext2fs/ext2_fs.h b/lib/ext2fs/ext2_fs.h
index a4141eb71..73e93f9b9 100644
--- a/lib/ext2fs/ext2_fs.h
+++ b/lib/ext2fs/ext2_fs.h
@@ -977,7 +977,8 @@ EXT4_FEATURE_INCOMPAT_FUNCS(casefold, 4, CASEFOLD)
#define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \
EXT4_FEATURE_INCOMPAT_MMP| \
EXT4_FEATURE_INCOMPAT_LARGEDIR| \
- EXT4_FEATURE_INCOMPAT_EA_INODE)
+ EXT4_FEATURE_INCOMPAT_EA_INODE| \
+ EXT4_FEATURE_INCOMPAT_DIRDATA)
#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
EXT4_FEATURE_RO_COMPAT_DIR_NLINK| \
@@ -1135,6 +1136,33 @@ static inline unsigned int ext2fs_dir_rec_len(__u8 name_len,
return rec_len;
}
+static inline unsigned int ext2fs_dirdata_rec_len(struct ext2_dir_entry *de,
+ int extended)
+{
+ int rec_len = EXT2_DIRENT_REC_LEN(de);
+
+ if (extended)
+ rec_len += EXT2_DIR_ENTRY_HASH_LEN;
+ return rec_len;
+}
+
+static inline unsigned int ext2fs_dir_rec_padding(struct ext2_dir_entry *de)
+{
+ unsigned int len = (de->name_len & EXT2_NAME_LEN) +
+ ext2_get_dirdata_size(de);
+
+ len &= EXT2_DIR_ROUND;
+ if (len)
+ len = EXT2_DIR_PAD - len;
+ return len;
+}
+
+/* lu_fid size and NUL char */
+#define EXT2_DIRENT_LUFID_SIZE 16
+#define EXT2_DIRENT_LUFID 0x10
+#define EXT2_DIRENT_INO64 0x20
+#define EXT2_DIRENT_CFHASH 0x40
+
#define EXT4_ORPHAN_BLOCK_MAGIC 0x0b10ca04
/* Structure at the tail of orphan block */
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index 374b8289e..91d269865 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -735,6 +735,7 @@ typedef struct ext2_icount *ext2_icount_t;
EXT3_FEATURE_INCOMPAT_EXTENTS|\
EXT4_FEATURE_INCOMPAT_FLEX_BG|\
EXT4_FEATURE_INCOMPAT_EA_INODE|\
+ EXT4_FEATURE_INCOMPAT_DIRDATA|\
EXT4_LIB_INCOMPAT_MMP|\
EXT4_FEATURE_INCOMPAT_64BIT|\
EXT4_FEATURE_INCOMPAT_INLINE_DATA|\
@@ -2340,7 +2341,7 @@ _INLINE_ __u64 ext2fs_div64_ceil(__u64 a, __u64 b)
_INLINE_ int ext2fs_dirent_name_len(const struct ext2_dir_entry *entry)
{
- return entry->name_len & 0xff;
+ return entry->name_len & EXT2_NAME_LEN;
}
_INLINE_ void ext2fs_dirent_set_name_len(struct ext2_dir_entry *entry, int len)
diff --git a/lib/ext2fs/lfsck.h b/lib/ext2fs/lfsck.h
new file mode 100644
index 000000000..ec763f720
--- /dev/null
+++ b/lib/ext2fs/lfsck.h
@@ -0,0 +1,47 @@
+#ifndef LFSCK_H
+#define LFSCK_H
+
+struct ext4_dirent_data_header {
+ /* length of this header + the whole data blob */
+ __u8 ddh_length;
+} __attribute__((packed));
+
+#ifndef DFID
+#define DFID "[%#llx:0x%x:0x%x]"
+#define PFID(fid) (unsigned long long)(fid)->f_seq, (fid)->f_oid, (fid)->f_ver
+struct lu_fid {
+ __u64 f_seq;
+ __u32 f_oid;
+ __u32 f_ver;
+};
+#endif /* !DFID */
+
+static inline void fid_be_to_cpu(struct lu_fid *dst, struct lu_fid *src)
+{
+ dst->f_seq = ext2fs_be64_to_cpu(src->f_seq);
+ dst->f_oid = ext2fs_be32_to_cpu(src->f_oid);
+ dst->f_ver = ext2fs_be32_to_cpu(src->f_ver);
+}
+
+struct ext4_dirent_lufid {
+ struct ext4_dirent_data_header df_header;
+ struct lu_fid df_fid[];
+};
+
+struct ext4_dir_entry_hash {
+ __le32 hash;
+ __le32 minor_hash;
+};
+
+struct ext4_dirent_hash {
+ struct ext4_dirent_data_header dh_header;
+ struct ext4_dir_entry_hash dh_hash;
+} __attribute__((packed));
+
+static inline void hash_le_to_cpu(struct ext4_dirent_hash *dst,
+ struct ext4_dirent_hash *src)
+{
+ dst->dh_hash.hash = ext2fs_le32_to_cpu(src->dh_hash.hash);
+ dst->dh_hash.minor_hash = ext2fs_le32_to_cpu(src->dh_hash.minor_hash);
+}
+#endif /* LFSCK_H */
--
2.43.7
^ permalink raw reply related
* [PATCH 02/13] ext2fs: Clean up directory entry handling APIs
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4
Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger, Pravin Shelar,
Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Refactor directory entry manipulation code to use more appropriate macros
and simplify API usage:
- Replace EXT2_DIR_REC_LEN(namelen) with EXT2_DIR_NAME_LEN(namelen)
to correctly calculate name length overhead instead of full record length
- Rename EXT2_DIR_REC_LEN to EXT2_DIRENT_REC_LEN to show that it counts dirent.
Pass directory entry structs directly to EXT2_DIRENT_REC_LEN() instead of
extracting name_len field separately, leveraging helper function in macro
- Use EXT2_FT_MASK constant instead of EXT2FS_LINK_FT_MASK for consistency
with standard ext2fs conventions
This improves code clarity and reduces API misuse by matching intent
(calculating name space vs. total record space) with the appropriate macro.
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Pravin Shelar <pravin@clusterfs.com>
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
e2fsck/pass1.c | 2 +-
e2fsck/pass2.c | 15 +++++++--------
lib/ext2fs/dirblock.c | 33 +++++++++++++++++++++++++++++++++
lib/ext2fs/ext2_fs.h | 17 ++++++++++++++++-
lib/ext2fs/inline_data.c | 14 +++++++-------
lib/ext2fs/link.c | 11 +++++------
lib/ext2fs/newdir.c | 4 ++--
7 files changed, 71 insertions(+), 25 deletions(-)
diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index fdde76cc2..39d1255f9 100644
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -770,7 +770,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx,
*/
memcpy(&dotdot, inode->i_block, sizeof(dotdot));
memcpy(&de, ((char *)inode->i_block) + EXT4_INLINE_DATA_DOTDOT_SIZE,
- EXT2_DIR_REC_LEN(0));
+ EXT2_DIR_NAME_LEN(0));
dotdot = ext2fs_le32_to_cpu(dotdot);
de.inode = ext2fs_le32_to_cpu(de.inode);
de.rec_len = ext2fs_le16_to_cpu(de.rec_len);
diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c
index 036c0022d..319e7e0e3 100644
--- a/e2fsck/pass2.c
+++ b/e2fsck/pass2.c
@@ -862,11 +862,11 @@ static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf)
d = dirbuf;
top = EXT2_DIRENT_TAIL(dirbuf, fs->blocksize);
- while (d->rec_len && !(d->rec_len & 0x3) && NEXT_DIRENT(d) <= top)
- d = NEXT_DIRENT(d);
+ while (d->rec_len && !(d->rec_len & 0x3) && EXT2_NEXT_DIRENT(d) <= top)
+ d = EXT2_NEXT_DIRENT(d);
if (d != top) {
- unsigned int min_size = EXT2_DIR_REC_LEN(
+ unsigned int min_size = EXT2_DIR_NAME_LEN(
ext2fs_dirent_name_len(dirbuf));
if (min_size > (char *)top - (char *)d)
return EXT2_ET_DIR_NO_SPACE_FOR_CSUM;
@@ -881,7 +881,6 @@ static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf)
return 0;
}
-#undef NEXT_DIRENT
static errcode_t fix_inline_dir_size(e2fsck_t ctx, ext2_ino_t ino,
size_t *inline_data_size,
@@ -900,7 +899,7 @@ static errcode_t fix_inline_dir_size(e2fsck_t ctx, ext2_ino_t ino,
*/
if (old_size > EXT4_MIN_INLINE_DATA_SIZE &&
old_size < EXT4_MIN_INLINE_DATA_SIZE +
- EXT2_DIR_REC_LEN(1)) {
+ EXT2_DIR_NAME_LEN(1)) {
old_size = EXT4_MIN_INLINE_DATA_SIZE;
new_size = old_size;
} else
@@ -1187,7 +1186,7 @@ inline_read_fail:
if (((inline_data_size & 3) ||
(inline_data_size > EXT4_MIN_INLINE_DATA_SIZE &&
inline_data_size < EXT4_MIN_INLINE_DATA_SIZE +
- EXT2_DIR_REC_LEN(1))) &&
+ EXT2_DIR_NAME_LEN(1))) &&
fix_problem(ctx, PR_2_BAD_INLINE_DIR_SIZE, &pctx)) {
errcode_t err = fix_inline_dir_size(ctx, ino,
&inline_data_size, &pctx,
@@ -1409,7 +1408,7 @@ skip_checksum:
memset(&dot, 0, sizeof(dot));
dirent = ˙
dirent->inode = ino;
- dirent->rec_len = EXT2_DIR_REC_LEN(1);
+ dirent->rec_len = EXT2_DIR_NAME_LEN(1);
dirent->name_len = 1 | filetype;
dirent->name[0] = '.';
} else if (dot_state == 1) {
@@ -1417,7 +1416,7 @@ skip_checksum:
dirent = &dotdot;
dirent->inode =
((struct ext2_dir_entry *)buf)->inode;
- dirent->rec_len = EXT2_DIR_REC_LEN(2);
+ dirent->rec_len = EXT2_DIR_NAME_LEN(2);
dirent->name_len = 2 | filetype;
dirent->name[0] = '.';
dirent->name[1] = '.';
diff --git a/lib/ext2fs/dirblock.c b/lib/ext2fs/dirblock.c
index 54b277728..d1d5a9e7f 100644
--- a/lib/ext2fs/dirblock.c
+++ b/lib/ext2fs/dirblock.c
@@ -50,6 +50,39 @@ errcode_t ext2fs_read_dir_block3(ext2_filsys fs, blk64_t block,
return ext2fs_read_dir_block4(fs, block, buf, flags, 0);
}
+/*
+ * Compute the dirdata length. This includes only optional extensions.
+ * Each extension has a bit set in the high 4 bits of
+ * de->file_type, and the extension length is the first byte in each entry.
+ */
+int ext2_get_dirdata_field_size(struct ext2_dir_entry *de,
+ __u8 dirdata_flags)
+{
+ char *lenp = de->name + (de->name_len & EXT2_NAME_LEN) + 1 /* NUL */;
+ __u8 extra_data_flags = (de->name_len & ~(EXT2_FT_MASK << 8)) >> 12;
+ int dlen = 0;
+
+ dirdata_flags >>= 4;
+ while ((extra_data_flags & dirdata_flags) != 0) {
+ if (extra_data_flags & 1) {
+ if (dirdata_flags & 1)
+ dlen += *lenp;
+
+ lenp += *lenp;
+ }
+ extra_data_flags >>= 1;
+ dirdata_flags >>= 1;
+ }
+
+ /* add NUL terminator byte to dirdata length */
+ return dlen + (dlen != 0);
+}
+
+int ext2_get_dirdata_size(struct ext2_dir_entry *de)
+{
+ return ext2_get_dirdata_field_size(de, ~EXT2_FT_MASK);
+}
+
errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
void *buf, int flags EXT2FS_ATTR((unused)))
{
diff --git a/lib/ext2fs/ext2_fs.h b/lib/ext2fs/ext2_fs.h
index fcd420556..a4141eb71 100644
--- a/lib/ext2fs/ext2_fs.h
+++ b/lib/ext2fs/ext2_fs.h
@@ -1091,6 +1091,10 @@ struct ext2_dir_entry_tail {
#define EXT2_FT_SYMLINK 7
#define EXT2_FT_MAX 8
+#define EXT2_FT_MASK 0x0f
+#if EXT4_FT_MAX > EXT4_FT_MASK
+#error "conflicting EXT4_FT_MAX and EXT4_FT_MASK"
+#endif
/*
* Annoyingly, e2fsprogs always swab16s ext2_dir_entry.name_len, so we
@@ -1100,6 +1104,9 @@ struct ext2_dir_entry_tail {
*/
#define EXT2_DIR_NAME_LEN_CSUM 0xDE00
+int ext2_get_dirdata_field_size(struct ext2_dir_entry *de, __u8 dirdata_flags);
+int ext2_get_dirdata_size(struct ext2_dir_entry *de);
+
/*
* EXT2_DIR_PAD defines the directory entries boundaries
*
@@ -1109,7 +1116,13 @@ struct ext2_dir_entry_tail {
#define EXT2_DIR_ENTRY_HASH_LEN 8
#define EXT2_DIR_PAD 4
#define EXT2_DIR_ROUND (EXT2_DIR_PAD - 1)
-#define EXT2_DIR_REC_LEN(name_len) ext2fs_dir_rec_len(name_len, 0)
+#define EXT2_DIR_NAME_LEN(name_len) (((name_len) + \
+ EXT2_DIR_ENTRY_HEADER_LEN + \
+ EXT2_DIR_ROUND) & \
+ ~EXT2_DIR_ROUND)
+#define EXT2_DIRENT_REC_LEN(de) (EXT2_DIR_NAME_LEN(((de)->name_len & \
+ EXT2_NAME_LEN) + \
+ ext2_get_dirdata_size(de)))
static inline unsigned int ext2fs_dir_rec_len(__u8 name_len,
int extended)
@@ -1202,4 +1215,6 @@ struct mmp_struct {
#define EXT4_ENC_STRICT_MODE_FL (1 << 0) /* Reject invalid sequences */
+#define EXT2_NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len))
+
#endif /* _LINUX_EXT2_FS_H */
diff --git a/lib/ext2fs/inline_data.c b/lib/ext2fs/inline_data.c
index bd52e3770..c8d2fa0ce 100644
--- a/lib/ext2fs/inline_data.c
+++ b/lib/ext2fs/inline_data.c
@@ -149,7 +149,7 @@ int ext2fs_inline_data_dir_iterate(ext2_filsys fs, ext2_ino_t ino,
/* we first check '.' and '..' dir */
dirent.inode = ino;
dirent.name_len = 1;
- ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(2), &dirent);
+ ext2fs_set_rec_len(fs, EXT2_DIR_NAME_LEN(2), &dirent);
dirent.name[0] = '.';
dirent.name[1] = '\0';
ctx->buf = (char *)&dirent;
@@ -160,7 +160,7 @@ int ext2fs_inline_data_dir_iterate(ext2_filsys fs, ext2_ino_t ino,
dirent.inode = ext2fs_le32_to_cpu(inode.i_block[0]);
dirent.name_len = 2;
- ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(3), &dirent);
+ ext2fs_set_rec_len(fs, EXT2_DIR_NAME_LEN(3), &dirent);
dirent.name[0] = '.';
dirent.name[1] = '.';
dirent.name[2] = '\0';
@@ -296,14 +296,14 @@ static errcode_t ext2fs_inline_data_convert_dir(ext2_filsys fs, ext2_ino_t ino,
ext2fs_dirent_set_name_len(dir, 1);
ext2fs_dirent_set_file_type(dir, filetype);
dir->name[0] = '.';
- rec_len = (fs->blocksize - csum_size) - EXT2_DIR_REC_LEN(1);
- dir->rec_len = EXT2_DIR_REC_LEN(1);
+ rec_len = (fs->blocksize - csum_size) - EXT2_DIR_NAME_LEN(1);
+ dir->rec_len = EXT2_DIR_NAME_LEN(1);
/*
* Set up entry for '..'
*/
dir = (struct ext2_dir_entry *) (bbuf + dir->rec_len);
- dir->rec_len = EXT2_DIR_REC_LEN(2);
+ dir->rec_len = EXT2_DIR_NAME_LEN(2);
dir->inode = ext2fs_le32_to_cpu(((__u32 *)ibuf)[0]);
ext2fs_dirent_set_name_len(dir, 2);
ext2fs_dirent_set_file_type(dir, filetype);
@@ -313,11 +313,11 @@ static errcode_t ext2fs_inline_data_convert_dir(ext2_filsys fs, ext2_ino_t ino,
/*
* Adjust the last rec_len
*/
- offset = EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2);
+ offset = EXT2_DIR_NAME_LEN(1) + EXT2_DIR_NAME_LEN(2);
dir = (struct ext2_dir_entry *) (bbuf + offset);
memcpy(bbuf + offset, ibuf + EXT4_INLINE_DATA_DOTDOT_SIZE,
size - EXT4_INLINE_DATA_DOTDOT_SIZE);
- size += EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) -
+ size += EXT2_DIR_NAME_LEN(1) + EXT2_DIR_NAME_LEN(2) -
EXT4_INLINE_DATA_DOTDOT_SIZE;
do {
diff --git a/lib/ext2fs/link.c b/lib/ext2fs/link.c
index eccbf0d23..151274663 100644
--- a/lib/ext2fs/link.c
+++ b/lib/ext2fs/link.c
@@ -197,7 +197,7 @@ static int link_proc(ext2_ino_t dir EXT2FS_ATTR((unused)),
if (ls->done)
return DIRENT_ABORT;
- rec_len = EXT2_DIR_REC_LEN(ls->namelen);
+ rec_len = EXT2_DIR_NAME_LEN(ls->namelen);
ls->err = ext2fs_get_rec_len(ls->fs, dirent, &curr_rec_len);
if (ls->err)
@@ -226,7 +226,7 @@ static int link_proc(ext2_ino_t dir EXT2FS_ATTR((unused)),
* truncate it and return.
*/
if (dirent->inode) {
- min_rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(dirent));
+ min_rec_len = EXT2_DIRENT_REC_LEN(dirent);
if (curr_rec_len < (min_rec_len + rec_len))
return ret;
rec_len = curr_rec_len - min_rec_len;
@@ -254,8 +254,7 @@ static int link_proc(ext2_ino_t dir EXT2FS_ATTR((unused)),
ext2fs_dirent_set_name_len(dirent, ls->namelen);
strncpy(dirent->name, ls->name, ls->namelen);
if (ext2fs_has_feature_filetype(ls->sb))
- ext2fs_dirent_set_file_type(dirent,
- ls->flags & EXT2FS_LINK_FT_MASK);
+ ext2fs_dirent_set_file_type(dirent, ls->flags & EXT2_FT_MASK);
ls->done++;
return DIRENT_ABORT|DIRENT_CHANGED;
@@ -331,8 +330,8 @@ static errcode_t dx_move_dirents(ext2_filsys fs, struct dx_hash_map *map,
csum_size = sizeof(struct ext2_dir_entry_tail);
for (i = 0; i < count; i++) {
- de = (struct ext2_dir_entry *) ((char *)from + map[i].off);
- rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(de));
+ de = from + map[i].off;
+ rec_len = EXT2_DIRENT_REC_LEN(de);
memcpy(to, de, rec_len);
retval = ext2fs_set_rec_len(fs, rec_len, to);
if (retval)
diff --git a/lib/ext2fs/newdir.c b/lib/ext2fs/newdir.c
index 7f4728500..f168d6686 100644
--- a/lib/ext2fs/newdir.c
+++ b/lib/ext2fs/newdir.c
@@ -64,8 +64,8 @@ errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
ext2fs_dirent_set_name_len(dir, 1);
ext2fs_dirent_set_file_type(dir, filetype);
dir->name[0] = '.';
- rec_len = (fs->blocksize - csum_size) - EXT2_DIR_REC_LEN(1);
- dir->rec_len = EXT2_DIR_REC_LEN(1);
+ rec_len = (fs->blocksize - csum_size) - EXT2_DIR_NAME_LEN(1);
+ dir->rec_len = EXT2_DIR_NAME_LEN(1);
/*
* Set up entry for '..'
--
2.43.7
^ permalink raw reply related
* [PATCH 01/13] ext2fs: Consolidate duplicate min/max macros
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4; +Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger
In-Reply-To: <20260524203658.12406-1-artem.blagodarenko@gmail.com>
Move duplicate min() and max() macro definitions from individual source
files (alloc.c, fallocate.c, rehash.c) to the common ext2fs.h header.
Add include guards to prevent redefinition warnings when files define
their own versions of these macros before including ext2fs.h.
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
lib/ext2fs/alloc.c | 2 --
lib/ext2fs/ext2fs.h | 9 +++++++++
lib/ext2fs/fallocate.c | 1 -
misc/e4defrag.c | 1 -
4 files changed, 9 insertions(+), 4 deletions(-)
diff --git a/lib/ext2fs/alloc.c b/lib/ext2fs/alloc.c
index 3fd921679..ff29b888e 100644
--- a/lib/ext2fs/alloc.c
+++ b/lib/ext2fs/alloc.c
@@ -26,8 +26,6 @@
#include "ext2_fs.h"
#include "ext2fs.h"
-#define min(a, b) ((a) < (b) ? (a) : (b))
-
#undef DEBUG
#ifdef DEBUG
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index c4fcb10be..374b8289e 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -134,6 +134,15 @@ typedef struct ext2fs_struct_generic_bitmap_base *ext2fs_block_bitmap;
#define EXT2_FIRST_INODE(s) EXT2_FIRST_INO(s)
+/*
+ * Utility macros
+ */
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
/*
* Badblocks list definitions
diff --git a/lib/ext2fs/fallocate.c b/lib/ext2fs/fallocate.c
index 1ef989cd3..82c18ab75 100644
--- a/lib/ext2fs/fallocate.c
+++ b/lib/ext2fs/fallocate.c
@@ -17,7 +17,6 @@
#include "ext2_fs.h"
#include "ext2fs.h"
-#define min(a, b) ((a) < (b) ? (a) : (b))
#undef DEBUG
diff --git a/misc/e4defrag.c b/misc/e4defrag.c
index 68e937fdb..e07f28cf6 100644
--- a/misc/e4defrag.c
+++ b/misc/e4defrag.c
@@ -59,7 +59,6 @@
fprintf(stderr, "\t%s\n", (msg))
#define STATISTIC_ERR_MSG_WITH_ERRNO(msg) \
fprintf(stderr, "\t%s:%s\n", (msg), strerror(errno))
-#define min(x, y) (((x) > (y)) ? (y) : (x))
#define CALC_SCORE(ratio) \
((ratio) > 10 ? (80 + 20 * (ratio) / 100) : (8 * (ratio)))
/* Wrap up the free function */
--
2.43.7
^ permalink raw reply related
* [PATCH 00/13] e2fsprogs: Add support for dirdata feature
From: Artem Blagodarenko @ 2026-05-24 20:36 UTC (permalink / raw)
To: linux-ext4; +Cc: adilger.kernel, Artem Blagodarenko
Add support for the INCOMPAT_DIRDATA feature, which allows
storing extra metadata in directory entries beyond the file
name. This provides a unified mechanism for extending directory
entries with additional information, including:
- hashes for encryption + casefold support
- unique 128-bit file identifiers
- high bits of 64-bit inode numbers
- future directory entry extensions
If directory hashes were stored before the dirdata feature was
introduced, the legacy hash format continues to be supported for
backward compatibility.
This series adds e2fsprogs support for DIRDATA, including:
- libext2fs: dirdata infrastructure and helper functions
- e2fsck: validation, repair, and reporting support for
dirdata fields
- debugfs: display of dirdata fields in directory listings
with the -ld option for testing and debugging
- mke2fs/tune2fs: user-visible support for enabling the
dirdata filesystem feature
The series also adds regression tests covering directory
optimization, duplicate directory entries, and dirdata field
preservation to ensure metadata integrity and prevent directory
corruption.
Artem Blagodarenko (13):
ext2fs: Consolidate duplicate min/max macros
ext2fs: Clean up directory entry handling APIs
ext2fs: dirdata infrastructure and core functions
libext2fs: add helper for dx_root_info lookup
e2fsck: pass2 dirdata validation and repair
e2fsck: dirdata message formatting and pass3 support
e2fsck: directory rehashing with dirdata support
debugfs: add dirdata display support
mke2fs/tune2fs: add dirdata feature support
e2fsck: add test suite for directory optimization
e2fsck: add test suite for duplicate directory entries
e2fsck: add test suite for dirdata-specific optimization
ext2fs: share list_dirdata code
debugfs/debugfs.8.in | 7 +-
debugfs/htree.c | 2 +-
debugfs/ls.c | 14 +-
debugfs/ncheck.c | 3 +
e2fsck/message.c | 2 +
e2fsck/pass1.c | 4 +-
e2fsck/pass2.c | 151 +++++++--
e2fsck/pass3.c | 7 +
e2fsck/problem.c | 5 +
e2fsck/problem.h | 3 +
e2fsck/rehash.c | 235 +++++++++-----
lib/ext2fs/alloc.c | 2 -
lib/ext2fs/dirblock.c | 84 +++++
lib/ext2fs/ext2_fs.h | 47 ++-
lib/ext2fs/ext2fs.h | 32 +-
lib/ext2fs/fallocate.c | 1 -
lib/ext2fs/inline_data.c | 14 +-
lib/ext2fs/lfsck.h | 47 +++
lib/ext2fs/link.c | 11 +-
lib/ext2fs/newdir.c | 4 +-
misc/e4defrag.c | 1 -
misc/mke2fs.c | 1 +
misc/tune2fs.c | 2 +
tests/f_dir_optimize/expect.1 | 511 ++++++++++++++++++++++++++++++
tests/f_dir_optimize/expect.2 | 511 ++++++++++++++++++++++++++++++
tests/f_dir_optimize/image.gz | Bin 0 -> 102520 bytes
tests/f_dir_optimize/name | 1 +
tests/f_dir_optimize/script | 36 +++
tests/f_dirdata_dup_de/expect.1 | 37 +++
tests/f_dirdata_dup_de/expect.2 | 7 +
tests/f_dirdata_dup_de/image.gz | Bin 0 -> 79307 bytes
tests/f_dirdata_dup_de/name | 1 +
tests/f_dirdata_mfid/expect.1 | 35 ++
tests/f_dirdata_mfid/expect.2 | 7 +
tests/f_dirdata_mfid/image.gz | Bin 0 -> 116296 bytes
tests/f_dirdata_mfid/name | 1 +
tests/f_dirdata_optimize/expect.1 | 10 +
tests/f_dirdata_optimize/expect.2 | 7 +
tests/f_dirdata_optimize/image.gz | Bin 0 -> 32121 bytes
tests/f_dirdata_optimize/name | 1 +
tests/f_dirdata_optimize/script | 3 +
41 files changed, 1714 insertions(+), 133 deletions(-)
create mode 100644 lib/ext2fs/lfsck.h
create mode 100644 tests/f_dir_optimize/expect.1
create mode 100644 tests/f_dir_optimize/expect.2
create mode 100644 tests/f_dir_optimize/image.gz
create mode 100644 tests/f_dir_optimize/name
create mode 100644 tests/f_dir_optimize/script
create mode 100644 tests/f_dirdata_dup_de/expect.1
create mode 100644 tests/f_dirdata_dup_de/expect.2
create mode 100644 tests/f_dirdata_dup_de/image.gz
create mode 100644 tests/f_dirdata_dup_de/name
create mode 100644 tests/f_dirdata_mfid/expect.1
create mode 100644 tests/f_dirdata_mfid/expect.2
create mode 100644 tests/f_dirdata_mfid/image.gz
create mode 100644 tests/f_dirdata_mfid/name
create mode 100644 tests/f_dirdata_optimize/expect.1
create mode 100644 tests/f_dirdata_optimize/expect.2
create mode 100644 tests/f_dirdata_optimize/image.gz
create mode 100644 tests/f_dirdata_optimize/name
create mode 100644 tests/f_dirdata_optimize/script
--
2.43.7
^ permalink raw reply
* [PATCH 01/13] ext2fs: Consolidate duplicate min/max macros
From: Artem Blagodarenko @ 2026-05-24 20:32 UTC (permalink / raw)
To: linux-ext4; +Cc: adilger.kernel, Artem Blagodarenko, Andreas Dilger
Move duplicate min() and max() macro definitions from individual source
files (alloc.c, fallocate.c, rehash.c) to the common ext2fs.h header.
Add include guards to prevent redefinition warnings when files define
their own versions of these macros before including ext2fs.h.
Signed-off-by: Artem Blagodarenko <artem.blagodarenko@gmail.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
---
lib/ext2fs/alloc.c | 2 --
lib/ext2fs/ext2fs.h | 9 +++++++++
lib/ext2fs/fallocate.c | 1 -
misc/e4defrag.c | 1 -
4 files changed, 9 insertions(+), 4 deletions(-)
diff --git a/lib/ext2fs/alloc.c b/lib/ext2fs/alloc.c
index 3fd921679..ff29b888e 100644
--- a/lib/ext2fs/alloc.c
+++ b/lib/ext2fs/alloc.c
@@ -26,8 +26,6 @@
#include "ext2_fs.h"
#include "ext2fs.h"
-#define min(a, b) ((a) < (b) ? (a) : (b))
-
#undef DEBUG
#ifdef DEBUG
diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index c4fcb10be..374b8289e 100644
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -134,6 +134,15 @@ typedef struct ext2fs_struct_generic_bitmap_base *ext2fs_block_bitmap;
#define EXT2_FIRST_INODE(s) EXT2_FIRST_INO(s)
+/*
+ * Utility macros
+ */
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
/*
* Badblocks list definitions
diff --git a/lib/ext2fs/fallocate.c b/lib/ext2fs/fallocate.c
index 1ef989cd3..82c18ab75 100644
--- a/lib/ext2fs/fallocate.c
+++ b/lib/ext2fs/fallocate.c
@@ -17,7 +17,6 @@
#include "ext2_fs.h"
#include "ext2fs.h"
-#define min(a, b) ((a) < (b) ? (a) : (b))
#undef DEBUG
diff --git a/misc/e4defrag.c b/misc/e4defrag.c
index 68e937fdb..e07f28cf6 100644
--- a/misc/e4defrag.c
+++ b/misc/e4defrag.c
@@ -59,7 +59,6 @@
fprintf(stderr, "\t%s\n", (msg))
#define STATISTIC_ERR_MSG_WITH_ERRNO(msg) \
fprintf(stderr, "\t%s:%s\n", (msg), strerror(errno))
-#define min(x, y) (((x) > (y)) ? (y) : (x))
#define CALC_SCORE(ratio) \
((ratio) > 10 ? (80 + 20 * (ratio) / 100) : (8 * (ratio)))
/* Wrap up the free function */
--
2.43.7
^ permalink raw reply related
* [BUG] ext4: WARNING in dquot_reclaim_space_nodirty on bigalloc + PUNCH_HOLE
From: Zijing Yin @ 2026-05-24 17:19 UTC (permalink / raw)
To: Theodore Ts'o, Jan Kara
Cc: Andreas Dilger, Baokun Li, Ojaswin Mujoo, Ritesh Harjani (IBM),
Zhang Yi, linux-ext4, linux-kernel, Zijing Yin
Hi,
A standalone C reproducer (attached) reliably trips two related
quota-accounting WARNs on current linux-next when run against an
ext4 bigalloc filesystem mounted with quota. The trigger workload
combines an O_DIRECT|RWF_DSYNC write at a sub-block-aligned offset,
a delayed-allocation single-byte write to a far-away logical
cluster, and a fallocate(FALLOC_FL_PUNCH_HOLE) that covers the
direct-I/O range but not the delayed cluster.
Reproduced on linux-next tag next-20260522. The same bug also
reproduces on plain mainline (torvalds/linux.git at commit
4cbfe4502e3d, 2026-05-23) and on the ext4 maintainer tree
(tytso/ext4.git#dev at 981fcc5674e6, 2026-04-09). The kernel was
built with x86_64 defconfig plus CONFIG_KASAN, CONFIG_LOCKDEP,
CONFIG_PROVE_LOCKING, CONFIG_QUOTA, CONFIG_QUOTA_DEBUG and
CONFIG_DEBUG_INFO (full .config attached). The attached repro.c
is a standalone C program that fires both WARNs deterministically
about 38 seconds after the bigalloc image is mounted, back-to-back
from the same process.
I was not able to land a fix despite a couple of attempts, so I'd
rather get the bug in front of the right eyes than ship a
misleading symptom mask.
The traces below are the dmesg captured by running attached
repro.c directly inside a QEMU VM booted with the linux-next
kernel above, then symbolised with `scripts/decode_stacktrace.sh
./vmlinux <source-tree>` against the same build.
------------[ cut here ]------------
WARNING: fs/quota/dquot.c:1887 at dquot_reclaim_space_nodirty+0x77c/0x8c0, CPU#0: repro_test/312
Modules linked in:
CPU: 0 UID: 0 PID: 312 Comm: repro_test Not tainted 7.1.0-rc4-next-20260522 #1 PREEMPT(lazy)
Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014
RIP: 0010:dquot_reclaim_space_nodirty (fs/quota/dquot.c:1887 (discriminator 1))
RSP: 0018:ff1100010ed67a10 EFLAGS: 00010293
RAX: 0000000000000000 RBX: ff1100010c7dae00 RCX: ffffffff821076c7
RDX: ff1100010eaca280 RSI: ffffffff82107bfc RDI: 0000000000000006
RBP: ff1100010ed67a70 R08: 00000000000005c0 R09: 0000000000000006
R10: 0000000000010000 R11: 0000000000000000 R12: ff110001105b3f10
R13: 0000000000000000 R14: 0000000000000001 R15: 0000000000010000
FS: 00000000069c9380(0000) GS:0000000000000000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000200000000140 CR3: 000000010ece7005 CR4: 0000000000771ef0
PKRU: 55555554
Call Trace:
<TASK>
ext4_rereserve_cluster (./include/linux/quotaops.h:361 fs/ext4/extents.c:2467)
ext4_ext_remove_space (fs/ext4/extents.c:3065)
? ext4_es_remove_extent (fs/ext4/extents_status.c:1669)
? __ext4_journal_start_sb (fs/ext4/ext4_jbd2.c:44 fs/ext4/ext4_jbd2.c:113)
? ext4_punch_hole (fs/ext4/ext4_jbd2.h:242 fs/ext4/inode.c:4486)
ext4_punch_hole (fs/ext4/inode.c:4508)
ext4_fallocate (fs/ext4/extents.c:4913)
vfs_fallocate (fs/open.c:338)
__x64_sys_fallocate (fs/open.c:362 fs/open.c:367 fs/open.c:365)
x64_sys_call (./arch/x86/include/generated/asm/syscalls_64.h:286)
do_syscall_64 (arch/x86/entry/syscall_64.c:63 arch/x86/entry/syscall_64.c:94)
entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:121)
</TASK>
---[ end trace 0000000000000000 ]---
A second related WARN fires moments later, in the writeback path
off the test program's file close:
------------[ cut here ]------------
WARNING: fs/quota/dquot.c:1846 at dquot_claim_space_nodirty+0x77c/0x8c0, CPU#0: repro_test/312
Modules linked in:
CPU: 0 UID: 0 PID: 312 Comm: repro_test Tainted: G W 7.1.0-rc4-next-20260522 #1 PREEMPT(lazy)
Tainted: [W]=WARN
RIP: 0010:dquot_claim_space_nodirty (fs/quota/dquot.c:1846 (discriminator 1))
RSP: 0018:ff1100010ed67250 EFLAGS: 00010293
RAX: 0000000000000000 RBX: ff1100010c7dae00 RCX: ffffffff82107f97
RDX: ff1100010eaca280 RSI: ffffffff821084cc RDI: 0000000000000006
RBP: ff1100010ed672b0 R08: 00000000000005c0 R09: 0000000000000004
R10: 0000000000010000 R11: 0000000000000000 R12: ff110001105b3f10
R13: 0000000000000000 R14: 0000000000000001 R15: 0000000000010000
FS: 0000000000000000(0000) GS:0000000000000000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fd79f6e86f8 CR3: 00000000098b6002 CR4: 0000000000771ef0
PKRU: 55555554
Call Trace:
<TASK>
ext4_da_update_reserve_space (./include/linux/quotaops.h:355 fs/ext4/inode.c:373)
ext4_es_insert_extent (fs/ext4/extents_status.c:1003)
? ext4_release_file (fs/ext4/file.c:169)
? ext4_map_blocks (fs/ext4/inode.c:823)
ext4_map_create_blocks (fs/ext4/inode.c:671)
ext4_map_blocks (fs/ext4/inode.c:824)
ext4_do_writepages (fs/ext4/inode.c:2396 fs/ext4/inode.c:2490 fs/ext4/inode.c:2948)
ext4_writepages (fs/ext4/inode.c:3042)
do_writepages (mm/page-writeback.c:2571)
filemap_writeback (mm/filemap.c:387)
filemap_flush (mm/filemap.c:436 mm/filemap.c:451)
ext4_alloc_da_blocks (fs/ext4/inode.c:3353)
ext4_release_file (fs/ext4/file.c:169)
__fput (fs/file_table.c:510)
____fput (fs/file_table.c:538)
task_work_run (kernel/task_work.c:233)
do_exit (./include/linux/task_work.h:40 kernel/exit.c:1004)
entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:121)
</TASK>
---[ end trace 0000000000000000 ]---
Happy to test instrumented kernels and candidate patches.
Attachments:
repro.c - standalone C reproducer, compiles with -static
repro.prog - syzkaller reproducer
config - kernel .config used for the build above
You can find them at:
https://bugzilla.kernel.org/show_bug.cgi?id=221570
Thanks,
Zijing
^ permalink raw reply
* [Bug 221570] [BUG] ext4: WARNING in dquot_reclaim_space_nodirty on bigalloc + PUNCH_HOLE
From: bugzilla-daemon @ 2026-05-24 17:12 UTC (permalink / raw)
To: linux-ext4
In-Reply-To: <bug-221570-13602@https.bugzilla.kernel.org/>
https://bugzilla.kernel.org/show_bug.cgi?id=221570
--- Comment #2 from yzjaurora@gmail.com ---
Created attachment 310190
--> https://bugzilla.kernel.org/attachment.cgi?id=310190&action=edit
C reproducer
--
You may reply to this email to add a comment.
You are receiving this mail because:
You are watching the assignee of the bug.
^ permalink raw reply
* [Bug 221570] [BUG] ext4: WARNING in dquot_reclaim_space_nodirty on bigalloc + PUNCH_HOLE
From: bugzilla-daemon @ 2026-05-24 17:12 UTC (permalink / raw)
To: linux-ext4
In-Reply-To: <bug-221570-13602@https.bugzilla.kernel.org/>
https://bugzilla.kernel.org/show_bug.cgi?id=221570
--- Comment #1 from yzjaurora@gmail.com ---
Created attachment 310189
--> https://bugzilla.kernel.org/attachment.cgi?id=310189&action=edit
Kernel config
--
You may reply to this email to add a comment.
You are receiving this mail because:
You are watching the assignee of the bug.
^ permalink raw reply
* [Bug 221570] New: [BUG] ext4: WARNING in dquot_reclaim_space_nodirty on bigalloc + PUNCH_HOLE
From: bugzilla-daemon @ 2026-05-24 17:11 UTC (permalink / raw)
To: linux-ext4
https://bugzilla.kernel.org/show_bug.cgi?id=221570
Bug ID: 221570
Summary: [BUG] ext4: WARNING in dquot_reclaim_space_nodirty on
bigalloc + PUNCH_HOLE
Product: File System
Version: 2.5
Hardware: All
OS: Linux
Status: NEW
Severity: normal
Priority: P3
Component: ext4
Assignee: fs_ext4@kernel-bugs.osdl.org
Reporter: yzjaurora@gmail.com
Regression: No
Created attachment 310188
--> https://bugzilla.kernel.org/attachment.cgi?id=310188&action=edit
Syzkaller reproducer
Hi,
A standalone C reproducer (attached) reliably trips two related
quota-accounting WARNs on current linux-next when run against an
ext4 bigalloc filesystem mounted with quota. The trigger workload
combines an O_DIRECT|RWF_DSYNC write at a sub-block-aligned offset,
a delayed-allocation single-byte write to a far-away logical
cluster, and a fallocate(FALLOC_FL_PUNCH_HOLE) that covers the
direct-I/O range but not the delayed cluster.
Reproduced on linux-next tag next-20260522. The same bug also
reproduces on plain mainline (torvalds/linux.git at commit
4cbfe4502e3d, 2026-05-23) and on the ext4 maintainer tree
(tytso/ext4.git#dev at 981fcc5674e6, 2026-04-09). The kernel was
built with x86_64 defconfig plus CONFIG_KASAN, CONFIG_LOCKDEP,
CONFIG_PROVE_LOCKING, CONFIG_QUOTA, CONFIG_QUOTA_DEBUG and
CONFIG_DEBUG_INFO (full .config attached). The attached repro.c
is a standalone C program that fires both WARNs deterministically
about 38 seconds after the bigalloc image is mounted, back-to-back
from the same process.
I was not able to land a fix despite a couple of attempts, so I'd
rather get the bug in front of the right eyes than ship a
misleading symptom mask.
The traces below are the dmesg captured by running attached
repro.c directly inside a QEMU VM booted with the linux-next
kernel above, then symbolised with `scripts/decode_stacktrace.sh
./vmlinux <source-tree>` against the same build.
------------[ cut here ]------------
WARNING: fs/quota/dquot.c:1887 at dquot_reclaim_space_nodirty+0x77c/0x8c0,
CPU#0: repro_test/312
Modules linked in:
CPU: 0 UID: 0 PID: 312 Comm: repro_test Not tainted 7.1.0-rc4-next-20260522 #1
PREEMPT(lazy)
Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS
1.16.3-debian-1.16.3-2 04/01/2014
RIP: 0010:dquot_reclaim_space_nodirty (fs/quota/dquot.c:1887 (discriminator 1))
RSP: 0018:ff1100010ed67a10 EFLAGS: 00010293
RAX: 0000000000000000 RBX: ff1100010c7dae00 RCX: ffffffff821076c7
RDX: ff1100010eaca280 RSI: ffffffff82107bfc RDI: 0000000000000006
RBP: ff1100010ed67a70 R08: 00000000000005c0 R09: 0000000000000006
R10: 0000000000010000 R11: 0000000000000000 R12: ff110001105b3f10
R13: 0000000000000000 R14: 0000000000000001 R15: 0000000000010000
FS: 00000000069c9380(0000) GS:0000000000000000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000200000000140 CR3: 000000010ece7005 CR4: 0000000000771ef0
PKRU: 55555554
Call Trace:
<TASK>
ext4_rereserve_cluster (./include/linux/quotaops.h:361 fs/ext4/extents.c:2467)
ext4_ext_remove_space (fs/ext4/extents.c:3065)
? ext4_es_remove_extent (fs/ext4/extents_status.c:1669)
? __ext4_journal_start_sb (fs/ext4/ext4_jbd2.c:44 fs/ext4/ext4_jbd2.c:113)
? ext4_punch_hole (fs/ext4/ext4_jbd2.h:242 fs/ext4/inode.c:4486)
ext4_punch_hole (fs/ext4/inode.c:4508)
ext4_fallocate (fs/ext4/extents.c:4913)
vfs_fallocate (fs/open.c:338)
__x64_sys_fallocate (fs/open.c:362 fs/open.c:367 fs/open.c:365)
x64_sys_call (./arch/x86/include/generated/asm/syscalls_64.h:286)
do_syscall_64 (arch/x86/entry/syscall_64.c:63 arch/x86/entry/syscall_64.c:94)
entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:121)
</TASK>
---[ end trace 0000000000000000 ]---
A second related WARN fires moments later, in the writeback path
off the test program's file close:
------------[ cut here ]------------
WARNING: fs/quota/dquot.c:1846 at dquot_claim_space_nodirty+0x77c/0x8c0, CPU#0:
repro_test/312
Modules linked in:
CPU: 0 UID: 0 PID: 312 Comm: repro_test Tainted: G W
7.1.0-rc4-next-20260522 #1 PREEMPT(lazy)
Tainted: [W]=WARN
RIP: 0010:dquot_claim_space_nodirty (fs/quota/dquot.c:1846 (discriminator 1))
RSP: 0018:ff1100010ed67250 EFLAGS: 00010293
RAX: 0000000000000000 RBX: ff1100010c7dae00 RCX: ffffffff82107f97
RDX: ff1100010eaca280 RSI: ffffffff821084cc RDI: 0000000000000006
RBP: ff1100010ed672b0 R08: 00000000000005c0 R09: 0000000000000004
R10: 0000000000010000 R11: 0000000000000000 R12: ff110001105b3f10
R13: 0000000000000000 R14: 0000000000000001 R15: 0000000000010000
FS: 0000000000000000(0000) GS:0000000000000000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fd79f6e86f8 CR3: 00000000098b6002 CR4: 0000000000771ef0
PKRU: 55555554
Call Trace:
<TASK>
ext4_da_update_reserve_space (./include/linux/quotaops.h:355
fs/ext4/inode.c:373)
ext4_es_insert_extent (fs/ext4/extents_status.c:1003)
? ext4_release_file (fs/ext4/file.c:169)
? ext4_map_blocks (fs/ext4/inode.c:823)
ext4_map_create_blocks (fs/ext4/inode.c:671)
ext4_map_blocks (fs/ext4/inode.c:824)
ext4_do_writepages (fs/ext4/inode.c:2396 fs/ext4/inode.c:2490
fs/ext4/inode.c:2948)
ext4_writepages (fs/ext4/inode.c:3042)
do_writepages (mm/page-writeback.c:2571)
filemap_writeback (mm/filemap.c:387)
filemap_flush (mm/filemap.c:436 mm/filemap.c:451)
ext4_alloc_da_blocks (fs/ext4/inode.c:3353)
ext4_release_file (fs/ext4/file.c:169)
__fput (fs/file_table.c:510)
____fput (fs/file_table.c:538)
task_work_run (kernel/task_work.c:233)
do_exit (./include/linux/task_work.h:40 kernel/exit.c:1004)
entry_SYSCALL_64_after_hwframe (arch/x86/entry/entry_64.S:121)
</TASK>
---[ end trace 0000000000000000 ]---
Happy to test instrumented kernels and candidate patches.
Attachments:
repro.c - standalone C reproducer, compiles with -static
repro.prog - syzkaller reproducer
config - kernel .config used for the build above
Reported-by: Zijing Yin <yzjaurora@gmail.com>
Thanks,
Zijing
--
You may reply to this email to add a comment.
You are receiving this mail because:
You are watching the assignee of the bug.
^ permalink raw reply
* [PATCH v4] ext2: Remove deprecated DAX support
From: Ashwin Gundarapu @ 2026-05-24 15:35 UTC (permalink / raw)
To: jack; +Cc: linux-ext4, linux-kernel
DAX support in ext2 was deprecated in commit d5a2693f93e4
("ext2: Deprecate DAX") with a removal deadline of end of 2025.
Remove all DAX code from ext2 as scheduled.
This removes the DAX mount option, IOMAP DAX support, DAX file
operations, DAX address_space_operations, and the DAX fault handler.
Signed-off-by: Ashwin Gundarapu <linuxuser509@zohomail.in>
---
v4: Changed Opt_xip and Opt_dax from -EINVAL to warning with break
to avoid mount failures. Removed dead XIP/DAX show_options code.
v3: Restored Opt_dax for graceful mount error message. Fixed remaining
space-to-tab indentation. Kept EXT2_MOUNT_XIP for compilation.
v2: Removed unused sbi variable and fixed indentation as reported
by kernel test robot.
---
fs/ext2/ext2.h | 5 +-
fs/ext2/file.c | 118 ++----------------------------------------------
fs/ext2/inode.c | 61 ++-----------------------
fs/ext2/super.c | 47 ++++---------------
4 files changed, 18 insertions(+), 213 deletions(-)
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 3eb1f342645c..3a26308ec841 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -114,8 +114,6 @@ struct ext2_sb_info {
*/
spinlock_t s_lock;
struct mb_cache *s_ea_block_cache;
- struct dax_device *s_daxdev;
- u64 s_dax_part_off;
};
static inline spinlock_t *
@@ -373,11 +371,10 @@ struct ext2_inode {
#define EXT2_MOUNT_NO_UID32 0x000200 /* Disable 32-bit UIDs */
#define EXT2_MOUNT_XATTR_USER 0x004000 /* Extended user attributes */
#define EXT2_MOUNT_POSIX_ACL 0x008000 /* POSIX Access Control Lists */
-#define EXT2_MOUNT_XIP 0x010000 /* Obsolete, use DAX */
+#define EXT2_MOUNT_XIP 0x010000 /* Obsolete*/
#define EXT2_MOUNT_USRQUOTA 0x020000 /* user quota */
#define EXT2_MOUNT_GRPQUOTA 0x040000 /* group quota */
#define EXT2_MOUNT_RESERVATION 0x080000 /* Preallocation */
-#define EXT2_MOUNT_DAX 0x100000 /* Direct Access */
#define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt
diff --git a/fs/ext2/file.c b/fs/ext2/file.c
index d9b1eb34694a..0fd9208af062 100644
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
@@ -21,7 +21,6 @@
#include <linux/time.h>
#include <linux/pagemap.h>
-#include <linux/dax.h>
#include <linux/filelock.h>
#include <linux/quotaops.h>
#include <linux/iomap.h>
@@ -32,111 +31,6 @@
#include "acl.h"
#include "trace.h"
-#ifdef CONFIG_FS_DAX
-static ssize_t ext2_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
-{
- struct inode *inode = iocb->ki_filp->f_mapping->host;
- ssize_t ret;
-
- if (!iov_iter_count(to))
- return 0; /* skip atime */
-
- inode_lock_shared(inode);
- ret = dax_iomap_rw(iocb, to, &ext2_iomap_ops);
- inode_unlock_shared(inode);
-
- file_accessed(iocb->ki_filp);
- return ret;
-}
-
-static ssize_t ext2_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
-{
- struct file *file = iocb->ki_filp;
- struct inode *inode = file->f_mapping->host;
- ssize_t ret;
-
- inode_lock(inode);
- ret = generic_write_checks(iocb, from);
- if (ret <= 0)
- goto out_unlock;
- ret = file_remove_privs(file);
- if (ret)
- goto out_unlock;
- ret = file_update_time(file);
- if (ret)
- goto out_unlock;
-
- ret = dax_iomap_rw(iocb, from, &ext2_iomap_ops);
- if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
- i_size_write(inode, iocb->ki_pos);
- mark_inode_dirty(inode);
- }
-
-out_unlock:
- inode_unlock(inode);
- if (ret > 0)
- ret = generic_write_sync(iocb, ret);
- return ret;
-}
-
-/*
- * The lock ordering for ext2 DAX fault paths is:
- *
- * mmap_lock (MM)
- * sb_start_pagefault (vfs, freeze)
- * address_space->invalidate_lock
- * address_space->i_mmap_rwsem or page_lock (mutually exclusive in DAX)
- * ext2_inode_info->truncate_mutex
- *
- * The default page_lock and i_size verification done by non-DAX fault paths
- * is sufficient because ext2 doesn't support hole punching.
- */
-static vm_fault_t ext2_dax_fault(struct vm_fault *vmf)
-{
- struct inode *inode = file_inode(vmf->vma->vm_file);
- vm_fault_t ret;
- bool write = (vmf->flags & FAULT_FLAG_WRITE) &&
- (vmf->vma->vm_flags & VM_SHARED);
-
- if (write) {
- sb_start_pagefault(inode->i_sb);
- file_update_time(vmf->vma->vm_file);
- }
- filemap_invalidate_lock_shared(inode->i_mapping);
-
- ret = dax_iomap_fault(vmf, 0, NULL, NULL, &ext2_iomap_ops);
-
- filemap_invalidate_unlock_shared(inode->i_mapping);
- if (write)
- sb_end_pagefault(inode->i_sb);
- return ret;
-}
-
-static const struct vm_operations_struct ext2_dax_vm_ops = {
- .fault = ext2_dax_fault,
- /*
- * .huge_fault is not supported for DAX because allocation in ext2
- * cannot be reliably aligned to huge page sizes and so pmd faults
- * will always fail and fail back to regular faults.
- */
- .page_mkwrite = ext2_dax_fault,
- .pfn_mkwrite = ext2_dax_fault,
-};
-
-static int ext2_file_mmap_prepare(struct vm_area_desc *desc)
-{
- struct file *file = desc->file;
-
- if (!IS_DAX(file_inode(file)))
- return generic_file_mmap_prepare(desc);
-
- file_accessed(file);
- desc->vm_ops = &ext2_dax_vm_ops;
- return 0;
-}
-#else
-#define ext2_file_mmap_prepare generic_file_mmap_prepare
-#endif
/*
* Called when filp is released. This happens when all file descriptors
@@ -285,10 +179,7 @@ static ssize_t ext2_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
-#ifdef CONFIG_FS_DAX
- if (IS_DAX(iocb->ki_filp->f_mapping->host))
- return ext2_dax_read_iter(iocb, to);
-#endif
+
if (iocb->ki_flags & IOCB_DIRECT)
return ext2_dio_read_iter(iocb, to);
@@ -297,10 +188,7 @@ static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
static ssize_t ext2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
-#ifdef CONFIG_FS_DAX
- if (IS_DAX(iocb->ki_filp->f_mapping->host))
- return ext2_dax_write_iter(iocb, from);
-#endif
+
if (iocb->ki_flags & IOCB_DIRECT)
return ext2_dio_write_iter(iocb, from);
@@ -321,7 +209,7 @@ const struct file_operations ext2_file_operations = {
#ifdef CONFIG_COMPAT
.compat_ioctl = ext2_compat_ioctl,
#endif
- .mmap_prepare = ext2_file_mmap_prepare,
+ .mmap_prepare = generic_file_mmap_prepare,
.open = ext2_file_open,
.release = ext2_release_file,
.fsync = ext2_fsync,
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 74aca5eb572d..e2aa6152fa1f 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -26,7 +26,6 @@
#include <linux/time.h>
#include <linux/highuid.h>
#include <linux/pagemap.h>
-#include <linux/dax.h>
#include <linux/blkdev.h>
#include <linux/quotaops.h>
#include <linux/writeback.h>
@@ -741,27 +740,6 @@ static int ext2_get_blocks(struct inode *inode,
goto cleanup;
}
- if (IS_DAX(inode)) {
- /*
- * We must unmap blocks before zeroing so that writeback cannot
- * overwrite zeros with stale data from block device page cache.
- */
- clean_bdev_aliases(inode->i_sb->s_bdev,
- le32_to_cpu(chain[depth-1].key),
- count);
- /*
- * block must be initialised before we put it in the tree
- * so that it's not found by another thread before it's
- * initialised
- */
- err = sb_issue_zeroout(inode->i_sb,
- le32_to_cpu(chain[depth-1].key), count,
- GFP_KERNEL);
- if (err) {
- mutex_unlock(&ei->truncate_mutex);
- goto cleanup;
- }
- }
*new = true;
ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
@@ -811,7 +789,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
unsigned int blkbits = inode->i_blkbits;
unsigned long first_block = offset >> blkbits;
unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
- struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
bool new = false, boundary = false;
u32 bno;
int ret;
@@ -841,10 +818,7 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
iomap->flags = 0;
iomap->offset = (u64)first_block << blkbits;
- if (flags & IOMAP_DAX)
- iomap->dax_dev = sbi->s_daxdev;
- else
- iomap->bdev = inode->i_sb->s_bdev;
+ iomap->bdev = inode->i_sb->s_bdev;
if (ret == 0) {
/*
@@ -859,8 +833,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
} else {
iomap->type = IOMAP_MAPPED;
iomap->addr = (u64)bno << blkbits;
- if (flags & IOMAP_DAX)
- iomap->addr += sbi->s_dax_part_off;
iomap->length = (u64)ret << blkbits;
iomap->flags |= IOMAP_F_MERGED;
}
@@ -962,13 +934,6 @@ ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
return mpage_writepages(mapping, wbc, ext2_get_block);
}
-static int
-ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc)
-{
- struct ext2_sb_info *sbi = EXT2_SB(mapping->host->i_sb);
-
- return dax_writeback_mapping_range(mapping, sbi->s_daxdev, wbc);
-}
const struct address_space_operations ext2_aops = {
.dirty_folio = block_dirty_folio,
@@ -984,10 +949,6 @@ const struct address_space_operations ext2_aops = {
.error_remove_folio = generic_error_remove_folio,
};
-static const struct address_space_operations ext2_dax_aops = {
- .writepages = ext2_dax_writepages,
- .dirty_folio = noop_dirty_folio,
-};
/*
* Probably it should be a library function... search for first non-zero word
@@ -1186,9 +1147,6 @@ static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
blocksize = inode->i_sb->s_blocksize;
iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
-#ifdef CONFIG_FS_DAX
- WARN_ON(!rwsem_is_locked(&inode->i_mapping->invalidate_lock));
-#endif
n = ext2_block_to_path(inode, iblock, offsets, NULL);
if (n == 0)
@@ -1290,12 +1248,8 @@ static int ext2_setsize(struct inode *inode, loff_t newsize)
inode_dio_wait(inode);
- if (IS_DAX(inode))
- error = dax_truncate_page(inode, newsize, NULL,
- &ext2_iomap_ops);
- else
- error = block_truncate_page(inode->i_mapping,
- newsize, ext2_get_block);
+ error = block_truncate_page(inode->i_mapping,
+ newsize, ext2_get_block);
if (error)
return error;
@@ -1363,7 +1317,7 @@ void ext2_set_inode_flags(struct inode *inode)
unsigned int flags = EXT2_I(inode)->i_flags;
inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME |
- S_DIRSYNC | S_DAX);
+ S_DIRSYNC);
if (flags & EXT2_SYNC_FL)
inode->i_flags |= S_SYNC;
if (flags & EXT2_APPEND_FL)
@@ -1374,18 +1328,13 @@ void ext2_set_inode_flags(struct inode *inode)
inode->i_flags |= S_NOATIME;
if (flags & EXT2_DIRSYNC_FL)
inode->i_flags |= S_DIRSYNC;
- if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode))
- inode->i_flags |= S_DAX;
}
void ext2_set_file_ops(struct inode *inode)
{
inode->i_op = &ext2_file_inode_operations;
inode->i_fop = &ext2_file_operations;
- if (IS_DAX(inode))
- inode->i_mapping->a_ops = &ext2_dax_aops;
- else
- inode->i_mapping->a_ops = &ext2_aops;
+ inode->i_mapping->a_ops = &ext2_aops;
}
struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 19f76d8cb473..39f67f1d63cc 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -34,7 +34,6 @@
#include <linux/log2.h>
#include <linux/quotaops.h>
#include <linux/uaccess.h>
-#include <linux/dax.h>
#include <linux/iversion.h>
#include "ext2.h"
#include "xattr.h"
@@ -198,7 +197,6 @@ static void ext2_put_super (struct super_block * sb)
brelse (sbi->s_sbh);
sb->s_fs_info = NULL;
kfree(sbi->s_blockgroup_lock);
- fs_put_dax(sbi->s_daxdev, NULL);
kfree(sbi);
}
@@ -329,11 +327,7 @@ static int ext2_show_options(struct seq_file *seq, struct dentry *root)
if (test_opt(sb, GRPQUOTA))
seq_puts(seq, ",grpquota");
- if (test_opt(sb, XIP))
- seq_puts(seq, ",xip");
- if (test_opt(sb, DAX))
- seq_puts(seq, ",dax");
if (!test_opt(sb, RESERVATION))
seq_puts(seq, ",noreservation");
@@ -595,20 +589,12 @@ static int ext2_parse_param(struct fs_context *fc, struct fs_parameter *param)
ext2_msg_fc(fc, KERN_INFO, "(no)acl options not supported");
break;
#endif
- case Opt_xip:
- ext2_msg_fc(fc, KERN_INFO, "use dax instead of xip");
- ctx_set_mount_opt(ctx, EXT2_MOUNT_XIP);
- fallthrough;
- case Opt_dax:
-#ifdef CONFIG_FS_DAX
- ext2_msg_fc(fc, KERN_WARNING,
- "DAX enabled. Warning: DAX support in ext2 driver is deprecated"
- " and will be removed at the end of 2025. Please use ext4 driver instead.");
- ctx_set_mount_opt(ctx, EXT2_MOUNT_DAX);
-#else
- ext2_msg_fc(fc, KERN_INFO, "dax option not supported");
-#endif
- break;
+ case Opt_xip:
+ ext2_msg_fc(fc, KERN_WARNING, "DAX support has been removed. xip option ignored.");
+ break;
+ case Opt_dax:
+ ext2_msg_fc(fc, KERN_WARNING, "DAX support has been removed. dax option ignored.");
+ break;
#if defined(CONFIG_QUOTA)
case Opt_quota:
@@ -906,8 +892,6 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
}
sb->s_fs_info = sbi;
sbi->s_sb_block = sb_block;
- sbi->s_daxdev = fs_dax_get_by_bdev(sb->s_bdev, &sbi->s_dax_part_off,
- NULL, NULL);
spin_lock_init(&sbi->s_lock);
ret = -EINVAL;
@@ -992,16 +976,8 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
}
blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
- if (test_opt(sb, DAX)) {
- if (!sbi->s_daxdev) {
- ext2_msg(sb, KERN_ERR,
- "DAX unsupported by block device. Turning off DAX.");
- clear_opt(sbi->s_mount_opt, DAX);
- } else if (blocksize != PAGE_SIZE) {
- ext2_msg(sb, KERN_ERR, "unsupported blocksize for DAX\n");
- clear_opt(sbi->s_mount_opt, DAX);
- }
- }
+
+
/* If the blocksize doesn't match, re-read the thing.. */
if (sb->s_blocksize != blocksize) {
@@ -1252,7 +1228,6 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
failed_mount:
brelse(bh);
failed_sbi:
- fs_put_dax(sbi->s_daxdev, NULL);
sb->s_fs_info = NULL;
kfree(sbi->s_blockgroup_lock);
kfree(sbi);
@@ -1379,11 +1354,7 @@ static int ext2_reconfigure(struct fs_context *fc)
spin_lock(&sbi->s_lock);
es = sbi->s_es;
- if ((sbi->s_mount_opt ^ new_opts.s_mount_opt) & EXT2_MOUNT_DAX) {
- ext2_msg(sb, KERN_WARNING, "warning: refusing change of "
- "dax flag with busy inodes while remounting");
- new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
- }
+
if ((bool)(flags & SB_RDONLY) == sb_rdonly(sb))
goto out_set;
if (flags & SB_RDONLY) {
--
2.43.0
^ permalink raw reply related
* [BUG] ext4: delayed-free buddy load error reaches BUG_ON in ext4_process_freed_data
From: Yifei Chu @ 2026-05-24 15:14 UTC (permalink / raw)
To: linux-ext4
Cc: Theodore Ts'o, Andreas Dilger, Baokun Li, Jan Kara,
Ojaswin Mujoo, Ritesh Harjani (IBM), Zhang Yi, linux-kernel
[-- Attachment #1.1: Type: text/plain, Size: 2241 bytes --]
Hello,
Short version: I am reporting an ext4 delayed-free error-path bug found
with targeted fault injection. The injected -EIO is in
ext4_mb_load_buddy()’s normal error-return domain, and the injection is
placed at the helper return boundary for the delayed-free caller. With that
rare lower-layer failure made deterministic, ext4_free_data_in_buddy()
reaches BUG_ON(err != 0) and crashes the kernel.
Tested kernel:
v7.1-rc4-640-g79bd2dded182
79bd2dded182b1d458b18e62684b7f82ffc682e5
x86_64 QEMU, KASAN config
The relevant code shape in fs/ext4/mballoc.c is:
err = ext4_mb_load_buddy(sb, entry->efd_group, &e4b);
/* we expect to find existing buddy because it’s pinned */
BUG_ON(err != 0);
The point of the injection is not to corrupt ext4 state. It only makes a
plausible buddy/bitmap load failure deterministic at this caller, so the
caller’s error handling can be tested. ext4_mb_load_buddy() already has
normal negative error returns from metadata loading paths.
Reproducer shape:
1. Mount a fresh ext4 filesystem.
2. Create and fsync a 256 KiB file.
3. Unlink the file.
4. Call sync() to force delayed-free processing.
5. The instrumentation forces ext4_mb_load_buddy() to return -EIO at the
delayed-free callsite.
Two fresh image runs reproduced the same crash:
AGENT_INIT: unlink ret=0 errno=0 (Success)
AGENT_INIT: calling sync to force delayed free processing
EXT4-fs: AGENT_EXT4_FREE_DATA_BUDDY_BUGON: forcing ext4_mb_load_buddy EIO
before BUG_ON
kernel BUG at fs/ext4/mballoc.c:3990!
Oops: invalid opcode: 0000 [#1] SMP KASAN NOPTI
RIP: 0010:ext4_process_freed_data+0x1fe/0x510
I did a local duplicate sweep and found related older
ext4_mb_load_buddy()/mballoc fixes, but I did not find a direct
current-upstream fix for this delayed-free BUG_ON(err != 0) path.
Expected behavior:
A metadata load failure during delayed-free processing should go through
ext4 error handling / transaction abort / filesystem error propagation,
rather than treating the error as an impossible invariant and BUGing the
kernel.
The attached tarball includes README.md, repro_init.c,
instrumentation.patch, and both full serial logs.
Thanks,
Chuyifei
[-- Attachment #1.2: Type: text/html, Size: 2397 bytes --]
[-- Attachment #2: ext4_free_data_buddy_load_error_bugon_20260524.tar.gz --]
[-- Type: application/x-tar, Size: 26948 bytes --]
^ permalink raw reply
* [PATCH v3] ext2: Remove deprecated DAX support
From: Ashwin Gundarapu @ 2026-05-24 9:39 UTC (permalink / raw)
To: jack; +Cc: linux-ext4, linux-kernel
DAX support in ext2 was deprecated in commit d5a2693f93e4
("ext2: Deprecate DAX") with a removal deadline of end of 2025.
Remove all DAX code from ext2 as scheduled.
This removes the DAX mount option, IOMAP DAX support, DAX file
operations, DAX address_space_operations, and the DAX fault handler.
Signed-off-by: Ashwin Gundarapu <linuxuser509@zohomail.in>
---
v3: Restored Opt_dax for graceful mount error message. Fixed remaining
space-to-tab indentation. Kept EXT2_MOUNT_XIP for compilation.
v2: Removed unused sbi variable and fixed indentation as reported
by kernel test robot.
---
fs/ext2/ext2.h | 5 +-
fs/ext2/file.c | 118 ++----------------------------------------------
fs/ext2/inode.c | 61 ++-----------------------
fs/ext2/super.c | 45 ++++--------------
4 files changed, 18 insertions(+), 211 deletions(-)
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 3eb1f342645c..3a26308ec841 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -114,8 +114,6 @@ struct ext2_sb_info {
*/
spinlock_t s_lock;
struct mb_cache *s_ea_block_cache;
- struct dax_device *s_daxdev;
- u64 s_dax_part_off;
};
static inline spinlock_t *
@@ -373,11 +371,10 @@ struct ext2_inode {
#define EXT2_MOUNT_NO_UID32 0x000200 /* Disable 32-bit UIDs */
#define EXT2_MOUNT_XATTR_USER 0x004000 /* Extended user attributes */
#define EXT2_MOUNT_POSIX_ACL 0x008000 /* POSIX Access Control Lists */
-#define EXT2_MOUNT_XIP 0x010000 /* Obsolete, use DAX */
+#define EXT2_MOUNT_XIP 0x010000 /* Obsolete*/
#define EXT2_MOUNT_USRQUOTA 0x020000 /* user quota */
#define EXT2_MOUNT_GRPQUOTA 0x040000 /* group quota */
#define EXT2_MOUNT_RESERVATION 0x080000 /* Preallocation */
-#define EXT2_MOUNT_DAX 0x100000 /* Direct Access */
#define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt
diff --git a/fs/ext2/file.c b/fs/ext2/file.c
index d9b1eb34694a..0fd9208af062 100644
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
@@ -21,7 +21,6 @@
#include <linux/time.h>
#include <linux/pagemap.h>
-#include <linux/dax.h>
#include <linux/filelock.h>
#include <linux/quotaops.h>
#include <linux/iomap.h>
@@ -32,111 +31,6 @@
#include "acl.h"
#include "trace.h"
-#ifdef CONFIG_FS_DAX
-static ssize_t ext2_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
-{
- struct inode *inode = iocb->ki_filp->f_mapping->host;
- ssize_t ret;
-
- if (!iov_iter_count(to))
- return 0; /* skip atime */
-
- inode_lock_shared(inode);
- ret = dax_iomap_rw(iocb, to, &ext2_iomap_ops);
- inode_unlock_shared(inode);
-
- file_accessed(iocb->ki_filp);
- return ret;
-}
-
-static ssize_t ext2_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
-{
- struct file *file = iocb->ki_filp;
- struct inode *inode = file->f_mapping->host;
- ssize_t ret;
-
- inode_lock(inode);
- ret = generic_write_checks(iocb, from);
- if (ret <= 0)
- goto out_unlock;
- ret = file_remove_privs(file);
- if (ret)
- goto out_unlock;
- ret = file_update_time(file);
- if (ret)
- goto out_unlock;
-
- ret = dax_iomap_rw(iocb, from, &ext2_iomap_ops);
- if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
- i_size_write(inode, iocb->ki_pos);
- mark_inode_dirty(inode);
- }
-
-out_unlock:
- inode_unlock(inode);
- if (ret > 0)
- ret = generic_write_sync(iocb, ret);
- return ret;
-}
-
-/*
- * The lock ordering for ext2 DAX fault paths is:
- *
- * mmap_lock (MM)
- * sb_start_pagefault (vfs, freeze)
- * address_space->invalidate_lock
- * address_space->i_mmap_rwsem or page_lock (mutually exclusive in DAX)
- * ext2_inode_info->truncate_mutex
- *
- * The default page_lock and i_size verification done by non-DAX fault paths
- * is sufficient because ext2 doesn't support hole punching.
- */
-static vm_fault_t ext2_dax_fault(struct vm_fault *vmf)
-{
- struct inode *inode = file_inode(vmf->vma->vm_file);
- vm_fault_t ret;
- bool write = (vmf->flags & FAULT_FLAG_WRITE) &&
- (vmf->vma->vm_flags & VM_SHARED);
-
- if (write) {
- sb_start_pagefault(inode->i_sb);
- file_update_time(vmf->vma->vm_file);
- }
- filemap_invalidate_lock_shared(inode->i_mapping);
-
- ret = dax_iomap_fault(vmf, 0, NULL, NULL, &ext2_iomap_ops);
-
- filemap_invalidate_unlock_shared(inode->i_mapping);
- if (write)
- sb_end_pagefault(inode->i_sb);
- return ret;
-}
-
-static const struct vm_operations_struct ext2_dax_vm_ops = {
- .fault = ext2_dax_fault,
- /*
- * .huge_fault is not supported for DAX because allocation in ext2
- * cannot be reliably aligned to huge page sizes and so pmd faults
- * will always fail and fail back to regular faults.
- */
- .page_mkwrite = ext2_dax_fault,
- .pfn_mkwrite = ext2_dax_fault,
-};
-
-static int ext2_file_mmap_prepare(struct vm_area_desc *desc)
-{
- struct file *file = desc->file;
-
- if (!IS_DAX(file_inode(file)))
- return generic_file_mmap_prepare(desc);
-
- file_accessed(file);
- desc->vm_ops = &ext2_dax_vm_ops;
- return 0;
-}
-#else
-#define ext2_file_mmap_prepare generic_file_mmap_prepare
-#endif
/*
* Called when filp is released. This happens when all file descriptors
@@ -285,10 +179,7 @@ static ssize_t ext2_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
-#ifdef CONFIG_FS_DAX
- if (IS_DAX(iocb->ki_filp->f_mapping->host))
- return ext2_dax_read_iter(iocb, to);
-#endif
+
if (iocb->ki_flags & IOCB_DIRECT)
return ext2_dio_read_iter(iocb, to);
@@ -297,10 +188,7 @@ static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
static ssize_t ext2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
-#ifdef CONFIG_FS_DAX
- if (IS_DAX(iocb->ki_filp->f_mapping->host))
- return ext2_dax_write_iter(iocb, from);
-#endif
+
if (iocb->ki_flags & IOCB_DIRECT)
return ext2_dio_write_iter(iocb, from);
@@ -321,7 +209,7 @@ const struct file_operations ext2_file_operations = {
#ifdef CONFIG_COMPAT
.compat_ioctl = ext2_compat_ioctl,
#endif
- .mmap_prepare = ext2_file_mmap_prepare,
+ .mmap_prepare = generic_file_mmap_prepare,
.open = ext2_file_open,
.release = ext2_release_file,
.fsync = ext2_fsync,
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 74aca5eb572d..e2aa6152fa1f 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -26,7 +26,6 @@
#include <linux/time.h>
#include <linux/highuid.h>
#include <linux/pagemap.h>
-#include <linux/dax.h>
#include <linux/blkdev.h>
#include <linux/quotaops.h>
#include <linux/writeback.h>
@@ -741,27 +740,6 @@ static int ext2_get_blocks(struct inode *inode,
goto cleanup;
}
- if (IS_DAX(inode)) {
- /*
- * We must unmap blocks before zeroing so that writeback cannot
- * overwrite zeros with stale data from block device page cache.
- */
- clean_bdev_aliases(inode->i_sb->s_bdev,
- le32_to_cpu(chain[depth-1].key),
- count);
- /*
- * block must be initialised before we put it in the tree
- * so that it's not found by another thread before it's
- * initialised
- */
- err = sb_issue_zeroout(inode->i_sb,
- le32_to_cpu(chain[depth-1].key), count,
- GFP_KERNEL);
- if (err) {
- mutex_unlock(&ei->truncate_mutex);
- goto cleanup;
- }
- }
*new = true;
ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
@@ -811,7 +789,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
unsigned int blkbits = inode->i_blkbits;
unsigned long first_block = offset >> blkbits;
unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
- struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
bool new = false, boundary = false;
u32 bno;
int ret;
@@ -841,10 +818,7 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
iomap->flags = 0;
iomap->offset = (u64)first_block << blkbits;
- if (flags & IOMAP_DAX)
- iomap->dax_dev = sbi->s_daxdev;
- else
- iomap->bdev = inode->i_sb->s_bdev;
+ iomap->bdev = inode->i_sb->s_bdev;
if (ret == 0) {
/*
@@ -859,8 +833,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
} else {
iomap->type = IOMAP_MAPPED;
iomap->addr = (u64)bno << blkbits;
- if (flags & IOMAP_DAX)
- iomap->addr += sbi->s_dax_part_off;
iomap->length = (u64)ret << blkbits;
iomap->flags |= IOMAP_F_MERGED;
}
@@ -962,13 +934,6 @@ ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
return mpage_writepages(mapping, wbc, ext2_get_block);
}
-static int
-ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc)
-{
- struct ext2_sb_info *sbi = EXT2_SB(mapping->host->i_sb);
-
- return dax_writeback_mapping_range(mapping, sbi->s_daxdev, wbc);
-}
const struct address_space_operations ext2_aops = {
.dirty_folio = block_dirty_folio,
@@ -984,10 +949,6 @@ const struct address_space_operations ext2_aops = {
.error_remove_folio = generic_error_remove_folio,
};
-static const struct address_space_operations ext2_dax_aops = {
- .writepages = ext2_dax_writepages,
- .dirty_folio = noop_dirty_folio,
-};
/*
* Probably it should be a library function... search for first non-zero word
@@ -1186,9 +1147,6 @@ static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
blocksize = inode->i_sb->s_blocksize;
iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
-#ifdef CONFIG_FS_DAX
- WARN_ON(!rwsem_is_locked(&inode->i_mapping->invalidate_lock));
-#endif
n = ext2_block_to_path(inode, iblock, offsets, NULL);
if (n == 0)
@@ -1290,12 +1248,8 @@ static int ext2_setsize(struct inode *inode, loff_t newsize)
inode_dio_wait(inode);
- if (IS_DAX(inode))
- error = dax_truncate_page(inode, newsize, NULL,
- &ext2_iomap_ops);
- else
- error = block_truncate_page(inode->i_mapping,
- newsize, ext2_get_block);
+ error = block_truncate_page(inode->i_mapping,
+ newsize, ext2_get_block);
if (error)
return error;
@@ -1363,7 +1317,7 @@ void ext2_set_inode_flags(struct inode *inode)
unsigned int flags = EXT2_I(inode)->i_flags;
inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME |
- S_DIRSYNC | S_DAX);
+ S_DIRSYNC);
if (flags & EXT2_SYNC_FL)
inode->i_flags |= S_SYNC;
if (flags & EXT2_APPEND_FL)
@@ -1374,18 +1328,13 @@ void ext2_set_inode_flags(struct inode *inode)
inode->i_flags |= S_NOATIME;
if (flags & EXT2_DIRSYNC_FL)
inode->i_flags |= S_DIRSYNC;
- if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode))
- inode->i_flags |= S_DAX;
}
void ext2_set_file_ops(struct inode *inode)
{
inode->i_op = &ext2_file_inode_operations;
inode->i_fop = &ext2_file_operations;
- if (IS_DAX(inode))
- inode->i_mapping->a_ops = &ext2_dax_aops;
- else
- inode->i_mapping->a_ops = &ext2_aops;
+ inode->i_mapping->a_ops = &ext2_aops;
}
struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 19f76d8cb473..6f24d1448a40 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -34,7 +34,6 @@
#include <linux/log2.h>
#include <linux/quotaops.h>
#include <linux/uaccess.h>
-#include <linux/dax.h>
#include <linux/iversion.h>
#include "ext2.h"
#include "xattr.h"
@@ -198,7 +197,6 @@ static void ext2_put_super (struct super_block * sb)
brelse (sbi->s_sbh);
sb->s_fs_info = NULL;
kfree(sbi->s_blockgroup_lock);
- fs_put_dax(sbi->s_daxdev, NULL);
kfree(sbi);
}
@@ -332,8 +330,6 @@ static int ext2_show_options(struct seq_file *seq, struct dentry *root)
if (test_opt(sb, XIP))
seq_puts(seq, ",xip");
- if (test_opt(sb, DAX))
- seq_puts(seq, ",dax");
if (!test_opt(sb, RESERVATION))
seq_puts(seq, ",noreservation");
@@ -595,20 +591,12 @@ static int ext2_parse_param(struct fs_context *fc, struct fs_parameter *param)
ext2_msg_fc(fc, KERN_INFO, "(no)acl options not supported");
break;
#endif
- case Opt_xip:
- ext2_msg_fc(fc, KERN_INFO, "use dax instead of xip");
- ctx_set_mount_opt(ctx, EXT2_MOUNT_XIP);
- fallthrough;
- case Opt_dax:
-#ifdef CONFIG_FS_DAX
- ext2_msg_fc(fc, KERN_WARNING,
- "DAX enabled. Warning: DAX support in ext2 driver is deprecated"
- " and will be removed at the end of 2025. Please use ext4 driver instead.");
- ctx_set_mount_opt(ctx, EXT2_MOUNT_DAX);
-#else
- ext2_msg_fc(fc, KERN_INFO, "dax option not supported");
-#endif
- break;
+ case Opt_xip:
+ ext2_msg_fc(fc, KERN_ERR, "DAX support has been removed. Please use ext4 instead.");
+ return -EINVAL;
+ case Opt_dax:
+ ext2_msg_fc(fc, KERN_ERR, "DAX support has been removed. Please use ext4 instead.");
+ return -EINVAL;
#if defined(CONFIG_QUOTA)
case Opt_quota:
@@ -906,8 +894,6 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
}
sb->s_fs_info = sbi;
sbi->s_sb_block = sb_block;
- sbi->s_daxdev = fs_dax_get_by_bdev(sb->s_bdev, &sbi->s_dax_part_off,
- NULL, NULL);
spin_lock_init(&sbi->s_lock);
ret = -EINVAL;
@@ -992,16 +978,8 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
}
blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
- if (test_opt(sb, DAX)) {
- if (!sbi->s_daxdev) {
- ext2_msg(sb, KERN_ERR,
- "DAX unsupported by block device. Turning off DAX.");
- clear_opt(sbi->s_mount_opt, DAX);
- } else if (blocksize != PAGE_SIZE) {
- ext2_msg(sb, KERN_ERR, "unsupported blocksize for DAX\n");
- clear_opt(sbi->s_mount_opt, DAX);
- }
- }
+
+
/* If the blocksize doesn't match, re-read the thing.. */
if (sb->s_blocksize != blocksize) {
@@ -1252,7 +1230,6 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
failed_mount:
brelse(bh);
failed_sbi:
- fs_put_dax(sbi->s_daxdev, NULL);
sb->s_fs_info = NULL;
kfree(sbi->s_blockgroup_lock);
kfree(sbi);
@@ -1379,11 +1356,7 @@ static int ext2_reconfigure(struct fs_context *fc)
spin_lock(&sbi->s_lock);
es = sbi->s_es;
- if ((sbi->s_mount_opt ^ new_opts.s_mount_opt) & EXT2_MOUNT_DAX) {
- ext2_msg(sb, KERN_WARNING, "warning: refusing change of "
- "dax flag with busy inodes while remounting");
- new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
- }
+
if ((bool)(flags & SB_RDONLY) == sb_rdonly(sb))
goto out_set;
if (flags & SB_RDONLY) {
--
2.43.0
^ permalink raw reply related
* [PATCH v2] ext2: Remove deprecated DAX support
From: Ashwin Gundarapu @ 2026-05-24 5:38 UTC (permalink / raw)
To: jack; +Cc: linux-ext4, linux-kernel
DAX support in ext2 was deprecated in commit d5a2693f93e4
("ext2: Deprecate DAX") with a removal deadline of end of 2025.
Remove all DAX code from ext2 as scheduled.
This removes the DAX mount option, IOMAP DAX support, DAX file
operations, DAX address_space_operations, and the DAX fault handler.
Signed-off-by: Ashwin Gundarapu <linuxuser509@zohomail.in>
---
v2: Removed unused sbi variable and fixed indentation as reported
by kernel test robot.
---
fs/ext2/ext2.h | 5 +-
fs/ext2/file.c | 118 ++----------------------------------------------
fs/ext2/inode.c | 61 ++-----------------------
fs/ext2/super.c | 45 +++---------------
4 files changed, 16 insertions(+), 213 deletions(-)
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 3eb1f342645c..3a26308ec841 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -114,8 +114,6 @@ struct ext2_sb_info {
*/
spinlock_t s_lock;
struct mb_cache *s_ea_block_cache;
- struct dax_device *s_daxdev;
- u64 s_dax_part_off;
};
static inline spinlock_t *
@@ -373,11 +371,10 @@ struct ext2_inode {
#define EXT2_MOUNT_NO_UID32 0x000200 /* Disable 32-bit UIDs */
#define EXT2_MOUNT_XATTR_USER 0x004000 /* Extended user attributes */
#define EXT2_MOUNT_POSIX_ACL 0x008000 /* POSIX Access Control Lists */
-#define EXT2_MOUNT_XIP 0x010000 /* Obsolete, use DAX */
+#define EXT2_MOUNT_XIP 0x010000 /* Obsolete*/
#define EXT2_MOUNT_USRQUOTA 0x020000 /* user quota */
#define EXT2_MOUNT_GRPQUOTA 0x040000 /* group quota */
#define EXT2_MOUNT_RESERVATION 0x080000 /* Preallocation */
-#define EXT2_MOUNT_DAX 0x100000 /* Direct Access */
#define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt
diff --git a/fs/ext2/file.c b/fs/ext2/file.c
index d9b1eb34694a..0fd9208af062 100644
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
@@ -21,7 +21,6 @@
#include <linux/time.h>
#include <linux/pagemap.h>
-#include <linux/dax.h>
#include <linux/filelock.h>
#include <linux/quotaops.h>
#include <linux/iomap.h>
@@ -32,111 +31,6 @@
#include "acl.h"
#include "trace.h"
-#ifdef CONFIG_FS_DAX
-static ssize_t ext2_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
-{
- struct inode *inode = iocb->ki_filp->f_mapping->host;
- ssize_t ret;
-
- if (!iov_iter_count(to))
- return 0; /* skip atime */
-
- inode_lock_shared(inode);
- ret = dax_iomap_rw(iocb, to, &ext2_iomap_ops);
- inode_unlock_shared(inode);
-
- file_accessed(iocb->ki_filp);
- return ret;
-}
-
-static ssize_t ext2_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
-{
- struct file *file = iocb->ki_filp;
- struct inode *inode = file->f_mapping->host;
- ssize_t ret;
-
- inode_lock(inode);
- ret = generic_write_checks(iocb, from);
- if (ret <= 0)
- goto out_unlock;
- ret = file_remove_privs(file);
- if (ret)
- goto out_unlock;
- ret = file_update_time(file);
- if (ret)
- goto out_unlock;
-
- ret = dax_iomap_rw(iocb, from, &ext2_iomap_ops);
- if (ret > 0 && iocb->ki_pos > i_size_read(inode)) {
- i_size_write(inode, iocb->ki_pos);
- mark_inode_dirty(inode);
- }
-
-out_unlock:
- inode_unlock(inode);
- if (ret > 0)
- ret = generic_write_sync(iocb, ret);
- return ret;
-}
-
-/*
- * The lock ordering for ext2 DAX fault paths is:
- *
- * mmap_lock (MM)
- * sb_start_pagefault (vfs, freeze)
- * address_space->invalidate_lock
- * address_space->i_mmap_rwsem or page_lock (mutually exclusive in DAX)
- * ext2_inode_info->truncate_mutex
- *
- * The default page_lock and i_size verification done by non-DAX fault paths
- * is sufficient because ext2 doesn't support hole punching.
- */
-static vm_fault_t ext2_dax_fault(struct vm_fault *vmf)
-{
- struct inode *inode = file_inode(vmf->vma->vm_file);
- vm_fault_t ret;
- bool write = (vmf->flags & FAULT_FLAG_WRITE) &&
- (vmf->vma->vm_flags & VM_SHARED);
-
- if (write) {
- sb_start_pagefault(inode->i_sb);
- file_update_time(vmf->vma->vm_file);
- }
- filemap_invalidate_lock_shared(inode->i_mapping);
-
- ret = dax_iomap_fault(vmf, 0, NULL, NULL, &ext2_iomap_ops);
-
- filemap_invalidate_unlock_shared(inode->i_mapping);
- if (write)
- sb_end_pagefault(inode->i_sb);
- return ret;
-}
-
-static const struct vm_operations_struct ext2_dax_vm_ops = {
- .fault = ext2_dax_fault,
- /*
- * .huge_fault is not supported for DAX because allocation in ext2
- * cannot be reliably aligned to huge page sizes and so pmd faults
- * will always fail and fail back to regular faults.
- */
- .page_mkwrite = ext2_dax_fault,
- .pfn_mkwrite = ext2_dax_fault,
-};
-
-static int ext2_file_mmap_prepare(struct vm_area_desc *desc)
-{
- struct file *file = desc->file;
-
- if (!IS_DAX(file_inode(file)))
- return generic_file_mmap_prepare(desc);
-
- file_accessed(file);
- desc->vm_ops = &ext2_dax_vm_ops;
- return 0;
-}
-#else
-#define ext2_file_mmap_prepare generic_file_mmap_prepare
-#endif
/*
* Called when filp is released. This happens when all file descriptors
@@ -285,10 +179,7 @@ static ssize_t ext2_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
-#ifdef CONFIG_FS_DAX
- if (IS_DAX(iocb->ki_filp->f_mapping->host))
- return ext2_dax_read_iter(iocb, to);
-#endif
+
if (iocb->ki_flags & IOCB_DIRECT)
return ext2_dio_read_iter(iocb, to);
@@ -297,10 +188,7 @@ static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
static ssize_t ext2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
-#ifdef CONFIG_FS_DAX
- if (IS_DAX(iocb->ki_filp->f_mapping->host))
- return ext2_dax_write_iter(iocb, from);
-#endif
+
if (iocb->ki_flags & IOCB_DIRECT)
return ext2_dio_write_iter(iocb, from);
@@ -321,7 +209,7 @@ const struct file_operations ext2_file_operations = {
#ifdef CONFIG_COMPAT
.compat_ioctl = ext2_compat_ioctl,
#endif
- .mmap_prepare = ext2_file_mmap_prepare,
+ .mmap_prepare = generic_file_mmap_prepare,
.open = ext2_file_open,
.release = ext2_release_file,
.fsync = ext2_fsync,
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 74aca5eb572d..193acff37270 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -26,7 +26,6 @@
#include <linux/time.h>
#include <linux/highuid.h>
#include <linux/pagemap.h>
-#include <linux/dax.h>
#include <linux/blkdev.h>
#include <linux/quotaops.h>
#include <linux/writeback.h>
@@ -741,27 +740,6 @@ static int ext2_get_blocks(struct inode *inode,
goto cleanup;
}
- if (IS_DAX(inode)) {
- /*
- * We must unmap blocks before zeroing so that writeback cannot
- * overwrite zeros with stale data from block device page cache.
- */
- clean_bdev_aliases(inode->i_sb->s_bdev,
- le32_to_cpu(chain[depth-1].key),
- count);
- /*
- * block must be initialised before we put it in the tree
- * so that it's not found by another thread before it's
- * initialised
- */
- err = sb_issue_zeroout(inode->i_sb,
- le32_to_cpu(chain[depth-1].key), count,
- GFP_KERNEL);
- if (err) {
- mutex_unlock(&ei->truncate_mutex);
- goto cleanup;
- }
- }
*new = true;
ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
@@ -811,7 +789,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
unsigned int blkbits = inode->i_blkbits;
unsigned long first_block = offset >> blkbits;
unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
- struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
bool new = false, boundary = false;
u32 bno;
int ret;
@@ -841,10 +818,7 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
iomap->flags = 0;
iomap->offset = (u64)first_block << blkbits;
- if (flags & IOMAP_DAX)
- iomap->dax_dev = sbi->s_daxdev;
- else
- iomap->bdev = inode->i_sb->s_bdev;
+ iomap->bdev = inode->i_sb->s_bdev;
if (ret == 0) {
/*
@@ -859,8 +833,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
} else {
iomap->type = IOMAP_MAPPED;
iomap->addr = (u64)bno << blkbits;
- if (flags & IOMAP_DAX)
- iomap->addr += sbi->s_dax_part_off;
iomap->length = (u64)ret << blkbits;
iomap->flags |= IOMAP_F_MERGED;
}
@@ -962,13 +934,6 @@ ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
return mpage_writepages(mapping, wbc, ext2_get_block);
}
-static int
-ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc)
-{
- struct ext2_sb_info *sbi = EXT2_SB(mapping->host->i_sb);
-
- return dax_writeback_mapping_range(mapping, sbi->s_daxdev, wbc);
-}
const struct address_space_operations ext2_aops = {
.dirty_folio = block_dirty_folio,
@@ -984,10 +949,6 @@ const struct address_space_operations ext2_aops = {
.error_remove_folio = generic_error_remove_folio,
};
-static const struct address_space_operations ext2_dax_aops = {
- .writepages = ext2_dax_writepages,
- .dirty_folio = noop_dirty_folio,
-};
/*
* Probably it should be a library function... search for first non-zero word
@@ -1186,9 +1147,6 @@ static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
blocksize = inode->i_sb->s_blocksize;
iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
-#ifdef CONFIG_FS_DAX
- WARN_ON(!rwsem_is_locked(&inode->i_mapping->invalidate_lock));
-#endif
n = ext2_block_to_path(inode, iblock, offsets, NULL);
if (n == 0)
@@ -1290,12 +1248,8 @@ static int ext2_setsize(struct inode *inode, loff_t newsize)
inode_dio_wait(inode);
- if (IS_DAX(inode))
- error = dax_truncate_page(inode, newsize, NULL,
- &ext2_iomap_ops);
- else
- error = block_truncate_page(inode->i_mapping,
- newsize, ext2_get_block);
+ error = block_truncate_page(inode->i_mapping,
+ newsize, ext2_get_block);
if (error)
return error;
@@ -1363,7 +1317,7 @@ void ext2_set_inode_flags(struct inode *inode)
unsigned int flags = EXT2_I(inode)->i_flags;
inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME |
- S_DIRSYNC | S_DAX);
+ S_DIRSYNC);
if (flags & EXT2_SYNC_FL)
inode->i_flags |= S_SYNC;
if (flags & EXT2_APPEND_FL)
@@ -1374,18 +1328,13 @@ void ext2_set_inode_flags(struct inode *inode)
inode->i_flags |= S_NOATIME;
if (flags & EXT2_DIRSYNC_FL)
inode->i_flags |= S_DIRSYNC;
- if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode))
- inode->i_flags |= S_DAX;
}
void ext2_set_file_ops(struct inode *inode)
{
inode->i_op = &ext2_file_inode_operations;
inode->i_fop = &ext2_file_operations;
- if (IS_DAX(inode))
- inode->i_mapping->a_ops = &ext2_dax_aops;
- else
- inode->i_mapping->a_ops = &ext2_aops;
+ inode->i_mapping->a_ops = &ext2_aops;
}
struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 19f76d8cb473..ede4ad84828c 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -34,7 +34,6 @@
#include <linux/log2.h>
#include <linux/quotaops.h>
#include <linux/uaccess.h>
-#include <linux/dax.h>
#include <linux/iversion.h>
#include "ext2.h"
#include "xattr.h"
@@ -198,7 +197,6 @@ static void ext2_put_super (struct super_block * sb)
brelse (sbi->s_sbh);
sb->s_fs_info = NULL;
kfree(sbi->s_blockgroup_lock);
- fs_put_dax(sbi->s_daxdev, NULL);
kfree(sbi);
}
@@ -332,8 +330,6 @@ static int ext2_show_options(struct seq_file *seq, struct dentry *root)
if (test_opt(sb, XIP))
seq_puts(seq, ",xip");
- if (test_opt(sb, DAX))
- seq_puts(seq, ",dax");
if (!test_opt(sb, RESERVATION))
seq_puts(seq, ",noreservation");
@@ -432,7 +428,7 @@ static const struct export_operations ext2_export_ops = {
enum {
Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid, Opt_resgid, Opt_resuid,
Opt_sb, Opt_errors, Opt_nouid32, Opt_debug, Opt_oldalloc, Opt_orlov,
- Opt_nobh, Opt_user_xattr, Opt_acl, Opt_xip, Opt_dax, Opt_ignore,
+ Opt_nobh, Opt_user_xattr, Opt_acl, Opt_xip, Opt_ignore,
Opt_quota, Opt_usrquota, Opt_grpquota, Opt_reservation,
};
@@ -462,7 +458,6 @@ static const struct fs_parameter_spec ext2_param_spec[] = {
fsparam_flag_no ("user_xattr", Opt_user_xattr),
fsparam_flag_no ("acl", Opt_acl),
fsparam_flag ("xip", Opt_xip),
- fsparam_flag ("dax", Opt_dax),
fsparam_flag ("grpquota", Opt_grpquota),
fsparam_flag ("noquota", Opt_ignore),
fsparam_flag ("quota", Opt_quota),
@@ -595,20 +590,9 @@ static int ext2_parse_param(struct fs_context *fc, struct fs_parameter *param)
ext2_msg_fc(fc, KERN_INFO, "(no)acl options not supported");
break;
#endif
- case Opt_xip:
- ext2_msg_fc(fc, KERN_INFO, "use dax instead of xip");
- ctx_set_mount_opt(ctx, EXT2_MOUNT_XIP);
- fallthrough;
- case Opt_dax:
-#ifdef CONFIG_FS_DAX
- ext2_msg_fc(fc, KERN_WARNING,
- "DAX enabled. Warning: DAX support in ext2 driver is deprecated"
- " and will be removed at the end of 2025. Please use ext4 driver instead.");
- ctx_set_mount_opt(ctx, EXT2_MOUNT_DAX);
-#else
- ext2_msg_fc(fc, KERN_INFO, "dax option not supported");
-#endif
- break;
+ case Opt_xip:
+ ext2_msg_fc(fc, KERN_ERR, "DAX support has been removed. Please use ext4 instead.");
+ return -EINVAL;
#if defined(CONFIG_QUOTA)
case Opt_quota:
@@ -906,8 +890,6 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
}
sb->s_fs_info = sbi;
sbi->s_sb_block = sb_block;
- sbi->s_daxdev = fs_dax_get_by_bdev(sb->s_bdev, &sbi->s_dax_part_off,
- NULL, NULL);
spin_lock_init(&sbi->s_lock);
ret = -EINVAL;
@@ -992,16 +974,8 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
}
blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
- if (test_opt(sb, DAX)) {
- if (!sbi->s_daxdev) {
- ext2_msg(sb, KERN_ERR,
- "DAX unsupported by block device. Turning off DAX.");
- clear_opt(sbi->s_mount_opt, DAX);
- } else if (blocksize != PAGE_SIZE) {
- ext2_msg(sb, KERN_ERR, "unsupported blocksize for DAX\n");
- clear_opt(sbi->s_mount_opt, DAX);
- }
- }
+
+
/* If the blocksize doesn't match, re-read the thing.. */
if (sb->s_blocksize != blocksize) {
@@ -1252,7 +1226,6 @@ static int ext2_fill_super(struct super_block *sb, struct fs_context *fc)
failed_mount:
brelse(bh);
failed_sbi:
- fs_put_dax(sbi->s_daxdev, NULL);
sb->s_fs_info = NULL;
kfree(sbi->s_blockgroup_lock);
kfree(sbi);
@@ -1379,11 +1352,7 @@ static int ext2_reconfigure(struct fs_context *fc)
spin_lock(&sbi->s_lock);
es = sbi->s_es;
- if ((sbi->s_mount_opt ^ new_opts.s_mount_opt) & EXT2_MOUNT_DAX) {
- ext2_msg(sb, KERN_WARNING, "warning: refusing change of "
- "dax flag with busy inodes while remounting");
- new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;
- }
+
if ((bool)(flags & SB_RDONLY) == sb_rdonly(sb))
goto out_set;
if (flags & SB_RDONLY) {
--
2.43.0
^ permalink raw reply related
* Re: [PATCH] ext2: Remove deprecated DAX support
From: kernel test robot @ 2026-05-24 4:06 UTC (permalink / raw)
To: Ashwin Gundarapu, jack; +Cc: oe-kbuild-all, linux-ext4, linux-kernel
In-Reply-To: <19e54c7cba1.5355cb8650862.622752146451851140@zohomail.in>
Hi Ashwin,
kernel test robot noticed the following build warnings:
[auto build test WARNING on jack-fs/for_next]
[also build test WARNING on linus/master v7.1-rc4 next-20260522]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Ashwin-Gundarapu/ext2-Remove-deprecated-DAX-support/20260523-202224
base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git for_next
patch link: https://lore.kernel.org/r/19e54c7cba1.5355cb8650862.622752146451851140%40zohomail.in
patch subject: [PATCH] ext2: Remove deprecated DAX support
config: i386-randconfig-141 (https://download.01.org/0day-ci/archive/20260524/202605241150.CHkeIFL0-lkp@intel.com/config)
compiler: gcc-14 (Debian 14.2.0-19) 14.2.0
smatch: v0.5.0-9185-gbcc58b9c
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202605241150.CHkeIFL0-lkp@intel.com/
smatch warnings:
fs/ext2/inode.c:1338 ext2_set_file_ops() warn: inconsistent indenting
vim +1338 fs/ext2/inode.c
^1da177e4c3f41 Linus Torvalds 2005-04-16 1333
fb094c90748fbe Dan Williams 2017-12-21 1334 void ext2_set_file_ops(struct inode *inode)
fb094c90748fbe Dan Williams 2017-12-21 1335 {
fb094c90748fbe Dan Williams 2017-12-21 1336 inode->i_op = &ext2_file_inode_operations;
fb094c90748fbe Dan Williams 2017-12-21 1337 inode->i_fop = &ext2_file_operations;
fb094c90748fbe Dan Williams 2017-12-21 @1338 inode->i_mapping->a_ops = &ext2_aops;
fb094c90748fbe Dan Williams 2017-12-21 1339 }
fb094c90748fbe Dan Williams 2017-12-21 1340
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
* [PATCH v6 v6 0/3] ext4: improve mballoc statistics reporting and control
From: Baolin Liu @ 2026-05-24 1:54 UTC (permalink / raw)
To: corbet, skhan, tytso, adilger.kernel, libaokun, jack, ojaswin,
ritesh.list, yi.zhang
Cc: linux-ext4, linux-kernel, Baolin Liu
From: Baolin Liu <liubaolin@kylinos.cn>
This series improves mballoc statistics reporting and control by adding
blocks_allocated to /proc/fs/ext4/<dev>/mb_stats, using
READ_ONCE()/WRITE_ONCE() for concurrent accesses to s_mb_stats, and
allowing mballoc stats to be controlled through
/proc/fs/ext4/<dev>/mb_stats.
Changes in v6:
- Serialize proc and sysfs updates to s_mb_stats with a mutex so that
clearing mb_stats through the proc control path cannot race with
concurrent administrative writes.
Baolin Liu (3):
ext4: add blocks_allocated to mb_stats output
ext4: use READ_ONCE/WRITE_ONCE for s_mb_stats
ext4: allow controlling mballoc stats through proc mb_stats
Documentation/ABI/testing/sysfs-fs-ext4 | 3 +-
Documentation/admin-guide/ext4.rst | 9 ++-
Documentation/filesystems/proc.rst | 13 +---
fs/ext4/ext4.h | 2 +
fs/ext4/mballoc.c | 58 ++++++++++++++----
fs/ext4/sysfs.c | 80 ++++++++++++++++++++++++-
6 files changed, 135 insertions(+), 30 deletions(-)
--
2.51.0
^ permalink raw reply
* [PATCH v6 v6 1/3] ext4: add blocks_allocated to mb_stats output
From: Baolin Liu @ 2026-05-24 1:54 UTC (permalink / raw)
To: corbet, skhan, tytso, adilger.kernel, libaokun, jack, ojaswin,
ritesh.list, yi.zhang
Cc: linux-ext4, linux-kernel, Baolin Liu, Andreas Dilger
In-Reply-To: <20260524015421.2529617-1-liubaolin12138@163.com>
From: Baolin Liu <liubaolin@kylinos.cn>
Add blocks_allocated to /proc/fs/ext4/<dev>/mb_stats so that the
reported statistics match the mballoc summary printed at unmount time.
Reviewed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
Reviewed-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
Reviewed-by: Zhang Yi <yi.zhang@huawei.com>
Signed-off-by: Baolin Liu <liubaolin@kylinos.cn>
---
fs/ext4/mballoc.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index bb58eafb87bc..d36b0f7b5d7d 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -3217,6 +3217,8 @@ int ext4_seq_mb_stats_show(struct seq_file *seq, void *offset)
"\tTo enable, please write \"1\" to sysfs file mb_stats.\n");
return 0;
}
+ seq_printf(seq, "\tblocks_allocated: %u\n",
+ atomic_read(&sbi->s_bal_allocated));
seq_printf(seq, "\treqs: %u\n", atomic_read(&sbi->s_bal_reqs));
seq_printf(seq, "\tsuccess: %u\n", atomic_read(&sbi->s_bal_success));
--
2.51.0
^ permalink raw reply related
* [PATCH v6 v6 3/3] ext4: allow controlling mballoc stats through proc mb_stats
From: Baolin Liu @ 2026-05-24 1:54 UTC (permalink / raw)
To: corbet, skhan, tytso, adilger.kernel, libaokun, jack, ojaswin,
ritesh.list, yi.zhang
Cc: linux-ext4, linux-kernel, Baolin Liu, Andreas Dilger
In-Reply-To: <20260524015421.2529617-1-liubaolin12138@163.com>
From: Baolin Liu <liubaolin@kylinos.cn>
Make /proc/fs/ext4/<dev>/mb_stats writable. Writing 0 disables mballoc
statistics collection, writing 1 enables it, and writing -1 clears the
current statistics before enabling collection.
Update the documentation and deprecate the sysfs mb_stats entry.
Reviewed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
Reviewed-by: Andreas Dilger <adilger@dilger.ca>
Reviewed-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
Reviewed-by: Zhang Yi <yi.zhang@huawei.com>
Reviewed-by: Baokun Li <libaokun@linux.alibaba.com>
Reviewed-by: Ted Tso <tytso@mit.edu>
Signed-off-by: Baolin Liu <liubaolin@kylinos.cn>
---
Documentation/ABI/testing/sysfs-fs-ext4 | 3 +-
Documentation/admin-guide/ext4.rst | 9 +++-
Documentation/filesystems/proc.rst | 13 +-----
fs/ext4/ext4.h | 2 +
fs/ext4/mballoc.c | 32 +++++++++++++-
fs/ext4/sysfs.c | 55 ++++++++++++++++++++++++-
6 files changed, 97 insertions(+), 17 deletions(-)
diff --git a/Documentation/ABI/testing/sysfs-fs-ext4 b/Documentation/ABI/testing/sysfs-fs-ext4
index 2edd0a6672d3..7bf06c533343 100644
--- a/Documentation/ABI/testing/sysfs-fs-ext4
+++ b/Documentation/ABI/testing/sysfs-fs-ext4
@@ -5,7 +5,8 @@ Description:
Controls whether the multiblock allocator should
collect statistics, which are shown during the unmount.
1 means to collect statistics, 0 means not to collect
- statistics
+ statistics. This sysfs entry is deprecated, and users
+ should prefer /proc/fs/ext4/<disk>/mb_stats.
What: /sys/fs/ext4/<disk>/mb_group_prealloc
Date: March 2008
diff --git a/Documentation/admin-guide/ext4.rst b/Documentation/admin-guide/ext4.rst
index ac0c709ea9e7..ca76e981b2aa 100644
--- a/Documentation/admin-guide/ext4.rst
+++ b/Documentation/admin-guide/ext4.rst
@@ -436,6 +436,12 @@ Files in /proc/fs/ext4/<devname>
mb_groups
details of multiblock allocator buddy cache of free blocks
+ mb_stats
+ reports runtime statistics from the multiblock allocator
+ (mballoc). Writing 0 disables statistics collection, writing
+ 1 enables statistics collection, and writing -1 clears the
+ current statistics and enables statistics collection.
+
/sys entries
============
@@ -493,7 +499,8 @@ Files in /sys/fs/ext4/<devname>:
mb_stats
Controls whether the multiblock allocator should collect statistics,
which are shown during the unmount. 1 means to collect statistics, 0
- means not to collect statistics.
+ means not to collect statistics. This sysfs entry is deprecated, and
+ users should prefer /proc/fs/ext4/<devname>/mb_stats.
mb_stream_req
Files which have fewer blocks than this tunable parameter will have
diff --git a/Documentation/filesystems/proc.rst b/Documentation/filesystems/proc.rst
index b0c0d1b45b99..dd487004b862 100644
--- a/Documentation/filesystems/proc.rst
+++ b/Documentation/filesystems/proc.rst
@@ -1623,18 +1623,7 @@ softirq.
1.8 Ext4 file system parameters
-------------------------------
-Information about mounted ext4 file systems can be found in
-/proc/fs/ext4. Each mounted filesystem will have a directory in
-/proc/fs/ext4 based on its device name (i.e., /proc/fs/ext4/hdc or
-/proc/fs/ext4/sda9 or /proc/fs/ext4/dm-0). The files in each per-device
-directory are shown in Table 1-12, below.
-
-.. table:: Table 1-12: Files in /proc/fs/ext4/<devname>
-
- ============== ==========================================================
- File Content
- mb_groups details of multiblock allocator buddy cache of free blocks
- ============== ==========================================================
+See Documentation/admin-guide/ext4.rst for ext4-specific /proc entries.
1.9 /proc/consoles
-------------------
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index df96bcd53a59..ab69ef8e5634 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1625,6 +1625,7 @@ struct ext4_sb_info {
unsigned int s_mb_stream_request;
unsigned int s_mb_max_to_scan;
unsigned int s_mb_min_to_scan;
+ struct mutex s_mb_stats_mutex;
unsigned int s_mb_stats;
unsigned int s_mb_order2_reqs;
unsigned int s_mb_group_prealloc;
@@ -2995,6 +2996,7 @@ int ext4_fc_record_regions(struct super_block *sb, int ino,
extern const struct seq_operations ext4_mb_seq_groups_ops;
extern const struct seq_operations ext4_mb_seq_structs_summary_ops;
extern int ext4_seq_mb_stats_show(struct seq_file *seq, void *offset);
+extern void ext4_mb_stats_clear(struct ext4_sb_info *sbi);
extern int ext4_mb_init(struct super_block *);
extern void ext4_mb_release(struct super_block *);
extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *,
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index fed6d854877b..ee8f62861941 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -3214,7 +3214,7 @@ int ext4_seq_mb_stats_show(struct seq_file *seq, void *offset)
seq_puts(seq, "\tmb stats collection turned off.\n");
seq_puts(
seq,
- "\tTo enable, please write \"1\" to sysfs file mb_stats.\n");
+ "\tTo enable, please write \"1\" to proc file mb_stats.\n");
return 0;
}
seq_printf(seq, "\tblocks_allocated: %u\n",
@@ -3787,6 +3787,7 @@ int ext4_mb_init(struct super_block *sb)
sbi->s_mb_max_to_scan = MB_DEFAULT_MAX_TO_SCAN;
sbi->s_mb_min_to_scan = MB_DEFAULT_MIN_TO_SCAN;
+ mutex_init(&sbi->s_mb_stats_mutex);
WRITE_ONCE(sbi->s_mb_stats, MB_DEFAULT_STATS);
sbi->s_mb_stream_request = MB_DEFAULT_STREAM_THRESHOLD;
sbi->s_mb_order2_reqs = MB_DEFAULT_ORDER2_REQS;
@@ -4723,6 +4724,35 @@ static void ext4_mb_collect_stats(struct ext4_allocation_context *ac)
trace_ext4_mballoc_prealloc(ac);
}
+void ext4_mb_stats_clear(struct ext4_sb_info *sbi)
+{
+ int i;
+
+ atomic_set(&sbi->s_bal_reqs, 0);
+ atomic_set(&sbi->s_bal_success, 0);
+ atomic_set(&sbi->s_bal_allocated, 0);
+ atomic_set(&sbi->s_bal_groups_scanned, 0);
+
+ for (i = 0; i < EXT4_MB_NUM_CRS; i++) {
+ atomic64_set(&sbi->s_bal_cX_hits[i], 0);
+ atomic64_set(&sbi->s_bal_cX_groups_considered[i], 0);
+ atomic_set(&sbi->s_bal_cX_ex_scanned[i], 0);
+ atomic64_set(&sbi->s_bal_cX_failed[i], 0);
+ }
+
+ atomic_set(&sbi->s_bal_ex_scanned, 0);
+ atomic_set(&sbi->s_bal_goals, 0);
+ atomic_set(&sbi->s_bal_stream_goals, 0);
+ atomic_set(&sbi->s_bal_len_goals, 0);
+ atomic_set(&sbi->s_bal_2orders, 0);
+ atomic_set(&sbi->s_bal_breaks, 0);
+ atomic_set(&sbi->s_mb_lost_chunks, 0);
+ atomic_set(&sbi->s_mb_buddies_generated, 0);
+ atomic64_set(&sbi->s_mb_generation_time, 0);
+ atomic_set(&sbi->s_mb_preallocated, 0);
+ atomic_set(&sbi->s_mb_discarded, 0);
+}
+
/*
* Called on failure; free up any blocks from the inode PA for this
* context. We don't need this for MB_GROUP_PA because we only change
diff --git a/fs/ext4/sysfs.c b/fs/ext4/sysfs.c
index 47e06c32c6fb..20935493dda8 100644
--- a/fs/ext4/sysfs.c
+++ b/fs/ext4/sysfs.c
@@ -53,6 +53,54 @@ typedef enum {
static const char proc_dirname[] = "fs/ext4";
static struct proc_dir_entry *ext4_proc_root;
+static int ext4_mb_stats_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, ext4_seq_mb_stats_show, pde_data(inode));
+}
+
+static ssize_t ext4_mb_stats_write(struct file *file, const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct super_block *sb = pde_data(file_inode(file));
+ struct ext4_sb_info *sbi = EXT4_SB(sb);
+ int val;
+ int ret;
+
+ ret = kstrtoint_from_user(buf, count, 0, &val);
+ if (ret)
+ return ret;
+
+ ret = count;
+ mutex_lock(&sbi->s_mb_stats_mutex);
+ switch (val) {
+ case -1:
+ WRITE_ONCE(sbi->s_mb_stats, 0);
+ ext4_mb_stats_clear(sbi);
+ WRITE_ONCE(sbi->s_mb_stats, 1);
+ break;
+ case 1:
+ WRITE_ONCE(sbi->s_mb_stats, 1);
+ break;
+ case 0:
+ WRITE_ONCE(sbi->s_mb_stats, 0);
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+ mutex_unlock(&sbi->s_mb_stats_mutex);
+
+ return ret;
+}
+
+static const struct proc_ops ext4_mb_stats_proc_ops = {
+ .proc_open = ext4_mb_stats_open,
+ .proc_read = seq_read,
+ .proc_lseek = seq_lseek,
+ .proc_release = single_release,
+ .proc_write = ext4_mb_stats_write,
+};
+
struct ext4_attr {
struct attribute attr;
short attr_id;
@@ -466,7 +514,10 @@ static ssize_t mb_stats_store(struct ext4_sb_info *sbi,
ret = kstrtouint(skip_spaces(buf), 0, &t);
if (ret)
return ret;
+
+ mutex_lock(&sbi->s_mb_stats_mutex);
WRITE_ONCE(sbi->s_mb_stats, t);
+ mutex_unlock(&sbi->s_mb_stats_mutex);
return len;
}
@@ -666,8 +717,8 @@ int ext4_register_sysfs(struct super_block *sb)
ext4_fc_info_show, sb);
proc_create_seq_data("mb_groups", S_IRUGO, sbi->s_proc,
&ext4_mb_seq_groups_ops, sb);
- proc_create_single_data("mb_stats", 0444, sbi->s_proc,
- ext4_seq_mb_stats_show, sb);
+ proc_create_data("mb_stats", 0644, sbi->s_proc,
+ &ext4_mb_stats_proc_ops, sb);
proc_create_seq_data("mb_structs_summary", 0444, sbi->s_proc,
&ext4_mb_seq_structs_summary_ops, sb);
}
--
2.51.0
^ permalink raw reply related
* [PATCH v6 v6 2/3] ext4: use READ_ONCE/WRITE_ONCE for s_mb_stats
From: Baolin Liu @ 2026-05-24 1:54 UTC (permalink / raw)
To: corbet, skhan, tytso, adilger.kernel, libaokun, jack, ojaswin,
ritesh.list, yi.zhang
Cc: linux-ext4, linux-kernel, Baolin Liu
In-Reply-To: <20260524015421.2529617-1-liubaolin12138@163.com>
From: Baolin Liu <liubaolin@kylinos.cn>
Use READ_ONCE()/WRITE_ONCE() for concurrent accesses to
s_mb_stats.
Signed-off-by: Baolin Liu <liubaolin@kylinos.cn>
---
fs/ext4/mballoc.c | 24 ++++++++++++------------
fs/ext4/sysfs.c | 25 ++++++++++++++++++++++++-
2 files changed, 36 insertions(+), 13 deletions(-)
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index d36b0f7b5d7d..fed6d854877b 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -924,7 +924,7 @@ static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
xa_for_each_range(xa, group, grp, start, end - 1) {
int err;
- if (sbi->s_mb_stats)
+ if (READ_ONCE(sbi->s_mb_stats))
atomic64_inc(&sbi->s_bal_cX_groups_considered[cr]);
err = ext4_mb_scan_group(ac, grp->bb_group);
@@ -980,7 +980,7 @@ static int ext4_mb_scan_groups_p2_aligned(struct ext4_allocation_context *ac,
goto wrap_around;
}
- if (sbi->s_mb_stats)
+ if (READ_ONCE(sbi->s_mb_stats))
atomic64_inc(&sbi->s_bal_cX_failed[ac->ac_criteria]);
/* Increment cr and search again if no group is found */
@@ -1031,7 +1031,7 @@ static int ext4_mb_scan_groups_goal_fast(struct ext4_allocation_context *ac,
goto wrap_around;
}
- if (sbi->s_mb_stats)
+ if (READ_ONCE(sbi->s_mb_stats))
atomic64_inc(&sbi->s_bal_cX_failed[ac->ac_criteria]);
/*
* CR_BEST_AVAIL_LEN works based on the concept that we have
@@ -1135,7 +1135,7 @@ static int ext4_mb_scan_groups_best_avail(struct ext4_allocation_context *ac,
/* Reset goal length to original goal length before falling into CR_GOAL_LEN_SLOW */
ac->ac_g_ex.fe_len = ac->ac_orig_goal_len;
- if (sbi->s_mb_stats)
+ if (READ_ONCE(sbi->s_mb_stats))
atomic64_inc(&sbi->s_bal_cX_failed[ac->ac_criteria]);
ac->ac_criteria = CR_GOAL_LEN_SLOW;
@@ -1184,7 +1184,7 @@ static int ext4_mb_scan_groups_linear(struct ext4_allocation_context *ac,
ac->ac_criteria++;
/* Processed all groups and haven't found blocks */
- if (sbi->s_mb_stats && i == ngroups)
+ if (READ_ONCE(sbi->s_mb_stats) && i == ngroups)
atomic64_inc(&sbi->s_bal_cX_failed[cr]);
return 0;
@@ -2541,7 +2541,7 @@ void ext4_mb_simple_scan_group(struct ext4_allocation_context *ac,
BUG_ON(ac->ac_f_ex.fe_len != ac->ac_g_ex.fe_len);
- if (EXT4_SB(sb)->s_mb_stats)
+ if (READ_ONCE(EXT4_SB(sb)->s_mb_stats))
atomic_inc(&EXT4_SB(sb)->s_bal_2orders);
break;
@@ -2786,7 +2786,7 @@ static int ext4_mb_good_group_nolock(struct ext4_allocation_context *ac,
if (!grp)
return -EFSCORRUPTED;
- if (sbi->s_mb_stats)
+ if (READ_ONCE(sbi->s_mb_stats))
atomic64_inc(&sbi->s_bal_cX_groups_considered[ac->ac_criteria]);
if (should_lock) {
ext4_lock_group(sb, group);
@@ -3097,7 +3097,7 @@ ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
}
}
- if (sbi->s_mb_stats && ac->ac_status == AC_STATUS_FOUND) {
+ if (READ_ONCE(sbi->s_mb_stats) && ac->ac_status == AC_STATUS_FOUND) {
atomic64_inc(&sbi->s_bal_cX_hits[ac->ac_criteria]);
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC &&
ac->ac_b_ex.fe_group == ac->ac_g_ex.fe_group)
@@ -3210,7 +3210,7 @@ int ext4_seq_mb_stats_show(struct seq_file *seq, void *offset)
struct ext4_sb_info *sbi = EXT4_SB(sb);
seq_puts(seq, "mballoc:\n");
- if (!sbi->s_mb_stats) {
+ if (!READ_ONCE(sbi->s_mb_stats)) {
seq_puts(seq, "\tmb stats collection turned off.\n");
seq_puts(
seq,
@@ -3787,7 +3787,7 @@ int ext4_mb_init(struct super_block *sb)
sbi->s_mb_max_to_scan = MB_DEFAULT_MAX_TO_SCAN;
sbi->s_mb_min_to_scan = MB_DEFAULT_MIN_TO_SCAN;
- sbi->s_mb_stats = MB_DEFAULT_STATS;
+ WRITE_ONCE(sbi->s_mb_stats, MB_DEFAULT_STATS);
sbi->s_mb_stream_request = MB_DEFAULT_STREAM_THRESHOLD;
sbi->s_mb_order2_reqs = MB_DEFAULT_ORDER2_REQS;
sbi->s_mb_best_avail_max_trim_order = MB_DEFAULT_BEST_AVAIL_TRIM_ORDER;
@@ -3929,7 +3929,7 @@ void ext4_mb_release(struct super_block *sb)
kfree(sbi->s_mb_offsets);
kfree(sbi->s_mb_maxs);
iput(sbi->s_buddy_cache);
- if (sbi->s_mb_stats) {
+ if (READ_ONCE(sbi->s_mb_stats)) {
ext4_msg(sb, KERN_INFO,
"mballoc: %u blocks %u reqs (%u success)",
atomic_read(&sbi->s_bal_allocated),
@@ -4694,7 +4694,7 @@ static void ext4_mb_collect_stats(struct ext4_allocation_context *ac)
{
struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
- if (sbi->s_mb_stats && ac->ac_g_ex.fe_len >= 1) {
+ if (READ_ONCE(sbi->s_mb_stats) && ac->ac_g_ex.fe_len >= 1) {
atomic_inc(&sbi->s_bal_reqs);
atomic_add(ac->ac_b_ex.fe_len, &sbi->s_bal_allocated);
if (ac->ac_b_ex.fe_len >= ac->ac_o_ex.fe_len)
diff --git a/fs/ext4/sysfs.c b/fs/ext4/sysfs.c
index afe12bcc1603..47e06c32c6fb 100644
--- a/fs/ext4/sysfs.c
+++ b/fs/ext4/sysfs.c
@@ -41,6 +41,7 @@ typedef enum {
attr_pointer_atomic,
attr_journal_task,
attr_err_report_sec,
+ attr_mb_stats,
} attr_id_t;
typedef enum {
@@ -241,6 +242,7 @@ EXT4_ATTR_FUNC(session_write_kbytes, 0444);
EXT4_ATTR_FUNC(lifetime_write_kbytes, 0444);
EXT4_ATTR_FUNC(reserved_clusters, 0644);
EXT4_ATTR_FUNC(sra_exceeded_retry_limit, 0444);
+EXT4_ATTR_FUNC(mb_stats, 0644);
EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, inode_readahead,
ext4_sb_info, s_inode_readahead_blks);
@@ -250,7 +252,6 @@ EXT4_ATTR_OFFSET(mb_best_avail_max_trim_order, 0644, mb_order,
ext4_sb_info, s_mb_best_avail_max_trim_order);
EXT4_ATTR_OFFSET(err_report_sec, 0644, err_report_sec, ext4_sb_info, s_err_report_sec);
EXT4_RW_ATTR_SBI_UI(inode_goal, s_inode_goal);
-EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
@@ -451,6 +452,24 @@ static ssize_t ext4_generic_attr_show(struct ext4_attr *a,
return 0;
}
+static ssize_t mb_stats_show(struct ext4_sb_info *sbi, char *buf)
+{
+ return sysfs_emit(buf, "%u\n", READ_ONCE(sbi->s_mb_stats));
+}
+
+static ssize_t mb_stats_store(struct ext4_sb_info *sbi,
+ const char *buf, size_t len)
+{
+ unsigned int t;
+ int ret;
+
+ ret = kstrtouint(skip_spaces(buf), 0, &t);
+ if (ret)
+ return ret;
+ WRITE_ONCE(sbi->s_mb_stats, t);
+ return len;
+}
+
static ssize_t ext4_attr_show(struct kobject *kobj,
struct attribute *attr, char *buf)
{
@@ -475,6 +494,8 @@ static ssize_t ext4_attr_show(struct kobject *kobj,
return sysfs_emit(buf, "%llu\n",
(unsigned long long)
percpu_counter_sum(&sbi->s_sra_exceeded_retry_limit));
+ case attr_mb_stats:
+ return mb_stats_show(sbi, buf);
case attr_feature:
return sysfs_emit(buf, "supported\n");
case attr_first_error_time:
@@ -559,6 +580,8 @@ static ssize_t ext4_attr_store(struct kobject *kobj,
return inode_readahead_blks_store(sbi, buf, len);
case attr_trigger_test_error:
return trigger_test_error(sbi, buf, len);
+ case attr_mb_stats:
+ return mb_stats_store(sbi, buf, len);
case attr_err_report_sec:
return err_report_sec_store(sbi, buf, len);
default:
--
2.51.0
^ permalink raw reply related
* Re: [PATCH] ext2: Remove deprecated DAX support
From: kernel test robot @ 2026-05-24 1:26 UTC (permalink / raw)
To: Ashwin Gundarapu, jack; +Cc: llvm, oe-kbuild-all, linux-ext4, linux-kernel
In-Reply-To: <19e54c7cba1.5355cb8650862.622752146451851140@zohomail.in>
Hi Ashwin,
kernel test robot noticed the following build warnings:
[auto build test WARNING on jack-fs/for_next]
[also build test WARNING on linus/master v7.1-rc4 next-20260522]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Ashwin-Gundarapu/ext2-Remove-deprecated-DAX-support/20260523-202224
base: https://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git for_next
patch link: https://lore.kernel.org/r/19e54c7cba1.5355cb8650862.622752146451851140%40zohomail.in
patch subject: [PATCH] ext2: Remove deprecated DAX support
config: riscv-nommu_virt_defconfig (https://download.01.org/0day-ci/archive/20260524/202605240952.dIQvDsdW-lkp@intel.com/config)
compiler: clang version 23.0.0git (https://github.com/llvm/llvm-project 5bac06718f502014fade905512f1d26d578a18f3)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260524/202605240952.dIQvDsdW-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202605240952.dIQvDsdW-lkp@intel.com/
All warnings (new ones prefixed by >>):
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:838:2: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
838 | insb(addr, buffer, count);
| ^~~~~~~~~~~~~~~~~~~~~~~~~
arch/riscv/include/asm/io.h:108:53: note: expanded from macro 'insb'
108 | #define insb(addr, buffer, count) __insb(PCI_IOBASE + (addr), buffer, count)
| ~~~~~~~~~~ ^
In file included from fs/ext2/inode.c:28:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:846:2: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
846 | insw(addr, buffer, count);
| ^~~~~~~~~~~~~~~~~~~~~~~~~
arch/riscv/include/asm/io.h:109:53: note: expanded from macro 'insw'
109 | #define insw(addr, buffer, count) __insw(PCI_IOBASE + (addr), buffer, count)
| ~~~~~~~~~~ ^
In file included from fs/ext2/inode.c:28:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:854:2: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
854 | insl(addr, buffer, count);
| ^~~~~~~~~~~~~~~~~~~~~~~~~
arch/riscv/include/asm/io.h:110:53: note: expanded from macro 'insl'
110 | #define insl(addr, buffer, count) __insl(PCI_IOBASE + (addr), buffer, count)
| ~~~~~~~~~~ ^
In file included from fs/ext2/inode.c:28:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:863:2: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
863 | outsb(addr, buffer, count);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
arch/riscv/include/asm/io.h:122:55: note: expanded from macro 'outsb'
122 | #define outsb(addr, buffer, count) __outsb(PCI_IOBASE + (addr), buffer, count)
| ~~~~~~~~~~ ^
In file included from fs/ext2/inode.c:28:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:872:2: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
872 | outsw(addr, buffer, count);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
arch/riscv/include/asm/io.h:123:55: note: expanded from macro 'outsw'
123 | #define outsw(addr, buffer, count) __outsw(PCI_IOBASE + (addr), buffer, count)
| ~~~~~~~~~~ ^
In file included from fs/ext2/inode.c:28:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:881:2: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
881 | outsl(addr, buffer, count);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~
arch/riscv/include/asm/io.h:124:55: note: expanded from macro 'outsl'
124 | #define outsl(addr, buffer, count) __outsl(PCI_IOBASE + (addr), buffer, count)
| ~~~~~~~~~~ ^
In file included from fs/ext2/inode.c:28:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from ./arch/riscv/include/generated/asm/hardirq.h:1:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/riscv/include/asm/io.h:140:
include/asm-generic/io.h:1209:55: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
1209 | return (port > MMIO_UPPER_LIMIT) ? NULL : PCI_IOBASE + port;
| ~~~~~~~~~~ ^
>> fs/ext2/inode.c:792:23: warning: unused variable 'sbi' [-Wunused-variable]
792 | struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
| ^~~
8 warnings generated.
vim +/sbi +792 fs/ext2/inode.c
a686cd898bd999f Martin J. Bligh 2007-10-16 785
25f4e70291a3097 Christoph Hellwig 2016-09-19 786 static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
c039b9979272634 Goldwyn Rodrigues 2019-10-18 787 unsigned flags, struct iomap *iomap, struct iomap *srcmap)
25f4e70291a3097 Christoph Hellwig 2016-09-19 788 {
25f4e70291a3097 Christoph Hellwig 2016-09-19 789 unsigned int blkbits = inode->i_blkbits;
25f4e70291a3097 Christoph Hellwig 2016-09-19 790 unsigned long first_block = offset >> blkbits;
25f4e70291a3097 Christoph Hellwig 2016-09-19 791 unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
8cf037a8b22f71c Dan Williams 2017-08-30 @792 struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
25f4e70291a3097 Christoph Hellwig 2016-09-19 793 bool new = false, boundary = false;
25f4e70291a3097 Christoph Hellwig 2016-09-19 794 u32 bno;
25f4e70291a3097 Christoph Hellwig 2016-09-19 795 int ret;
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 796) bool create = flags & IOMAP_WRITE;
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 797)
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 798) /*
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 799) * For writes that could fill holes inside i_size on a
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 800) * DIO_SKIP_HOLES filesystem we forbid block creations: only
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 801) * overwrites are permitted.
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 802) */
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 803) if ((flags & IOMAP_DIRECT) &&
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 804) (first_block << blkbits) < i_size_read(inode))
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 805) create = 0;
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 806)
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 807) /*
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 808) * Writes that span EOF might trigger an IO size update on completion,
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 809) * so consider them to be dirty for the purposes of O_DSYNC even if
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 810) * there is no other metadata changes pending or have been made here.
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 811) */
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 812) if ((flags & IOMAP_WRITE) && offset + length > i_size_read(inode))
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 813) iomap->flags |= IOMAP_F_DIRTY;
25f4e70291a3097 Christoph Hellwig 2016-09-19 814
25f4e70291a3097 Christoph Hellwig 2016-09-19 815 ret = ext2_get_blocks(inode, first_block, max_blocks,
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 816) &bno, &new, &boundary, create);
25f4e70291a3097 Christoph Hellwig 2016-09-19 817 if (ret < 0)
a686cd898bd999f Martin J. Bligh 2007-10-16 818 return ret;
a686cd898bd999f Martin J. Bligh 2007-10-16 819
25f4e70291a3097 Christoph Hellwig 2016-09-19 820 iomap->flags = 0;
d5bfccdf38d094f Christoph Hellwig 2016-10-03 821 iomap->offset = (u64)first_block << blkbits;
de2051147771017 Christoph Hellwig 2021-11-29 822 iomap->bdev = inode->i_sb->s_bdev;
25f4e70291a3097 Christoph Hellwig 2016-09-19 823
25f4e70291a3097 Christoph Hellwig 2016-09-19 824 if (ret == 0) {
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 825) /*
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 826) * Switch to buffered-io for writing to holes in a non-extent
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 827) * based filesystem to avoid stale data exposure problem.
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 828) */
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 829) if (!create && (flags & IOMAP_WRITE) && (flags & IOMAP_DIRECT))
fb5de4358e1aa47 Ritesh Harjani (IBM 2023-04-21 830) return -ENOTBLK;
25f4e70291a3097 Christoph Hellwig 2016-09-19 831 iomap->type = IOMAP_HOLE;
19fe5f643f89f29 Andreas Gruenbacher 2017-10-01 832 iomap->addr = IOMAP_NULL_ADDR;
25f4e70291a3097 Christoph Hellwig 2016-09-19 833 iomap->length = 1 << blkbits;
25f4e70291a3097 Christoph Hellwig 2016-09-19 834 } else {
25f4e70291a3097 Christoph Hellwig 2016-09-19 835 iomap->type = IOMAP_MAPPED;
19fe5f643f89f29 Andreas Gruenbacher 2017-10-01 836 iomap->addr = (u64)bno << blkbits;
25f4e70291a3097 Christoph Hellwig 2016-09-19 837 iomap->length = (u64)ret << blkbits;
25f4e70291a3097 Christoph Hellwig 2016-09-19 838 iomap->flags |= IOMAP_F_MERGED;
25f4e70291a3097 Christoph Hellwig 2016-09-19 839 }
25f4e70291a3097 Christoph Hellwig 2016-09-19 840
25f4e70291a3097 Christoph Hellwig 2016-09-19 841 if (new)
25f4e70291a3097 Christoph Hellwig 2016-09-19 842 iomap->flags |= IOMAP_F_NEW;
25f4e70291a3097 Christoph Hellwig 2016-09-19 843 return 0;
a686cd898bd999f Martin J. Bligh 2007-10-16 844 }
a686cd898bd999f Martin J. Bligh 2007-10-16 845
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox