tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ext4: implemet new ioctls to set and get superblock parameters

Implement the EXT4_IOC_GET_TUNE_SB_PARAM and
EXT4_IOC_SET_TUNE_SB_PARAM ioctls, which allow certains superblock
parameters to be set while the file system is mounted, without needing
write access to the block device.

Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Message-ID: <20250916-tune2fs-v2-3-d594dc7486f0@mit.edu>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

Theodore Ts'o 04a91570 12c84dd4

+358 -7
+305 -7
fs/ext4/ioctl.c
··· 27 27 #include "fsmap.h" 28 28 #include <trace/events/ext4.h> 29 29 30 - typedef void ext4_update_sb_callback(struct ext4_super_block *es, 31 - const void *arg); 30 + typedef void ext4_update_sb_callback(struct ext4_sb_info *sbi, 31 + struct ext4_super_block *es, 32 + const void *arg); 32 33 33 34 /* 34 35 * Superblock modification callback function for changing file system 35 36 * label 36 37 */ 37 - static void ext4_sb_setlabel(struct ext4_super_block *es, const void *arg) 38 + static void ext4_sb_setlabel(struct ext4_sb_info *sbi, 39 + struct ext4_super_block *es, const void *arg) 38 40 { 39 41 /* Sanity check, this should never happen */ 40 42 BUILD_BUG_ON(sizeof(es->s_volume_name) < EXT4_LABEL_MAX); ··· 48 46 * Superblock modification callback function for changing file system 49 47 * UUID. 50 48 */ 51 - static void ext4_sb_setuuid(struct ext4_super_block *es, const void *arg) 49 + static void ext4_sb_setuuid(struct ext4_sb_info *sbi, 50 + struct ext4_super_block *es, const void *arg) 52 51 { 53 52 memcpy(es->s_uuid, (__u8 *)arg, UUID_SIZE); 54 53 } ··· 74 71 goto out_err; 75 72 76 73 lock_buffer(bh); 77 - func(es, arg); 74 + func(sbi, es, arg); 78 75 ext4_superblock_csum_set(sb); 79 76 unlock_buffer(bh); 80 77 ··· 152 149 unlock_buffer(bh); 153 150 goto out_bh; 154 151 } 155 - func(es, arg); 152 + func(EXT4_SB(sb), es, arg); 156 153 if (ext4_has_feature_metadata_csum(sb)) 157 154 es->s_checksum = ext4_superblock_csum(es); 158 155 set_buffer_uptodate(bh); ··· 1233 1230 return ret; 1234 1231 } 1235 1232 1233 + 1234 + #define TUNE_OPS_SUPPORTED (EXT4_TUNE_FL_ERRORS_BEHAVIOR | \ 1235 + EXT4_TUNE_FL_MNT_COUNT | EXT4_TUNE_FL_MAX_MNT_COUNT | \ 1236 + EXT4_TUNE_FL_CHECKINTRVAL | EXT4_TUNE_FL_LAST_CHECK_TIME | \ 1237 + EXT4_TUNE_FL_RESERVED_BLOCKS | EXT4_TUNE_FL_RESERVED_UID | \ 1238 + EXT4_TUNE_FL_RESERVED_GID | EXT4_TUNE_FL_DEFAULT_MNT_OPTS | \ 1239 + EXT4_TUNE_FL_DEF_HASH_ALG | EXT4_TUNE_FL_RAID_STRIDE | \ 1240 + EXT4_TUNE_FL_RAID_STRIPE_WIDTH | EXT4_TUNE_FL_MOUNT_OPTS | \ 1241 + EXT4_TUNE_FL_FEATURES | EXT4_TUNE_FL_EDIT_FEATURES | \ 1242 + EXT4_TUNE_FL_FORCE_FSCK | EXT4_TUNE_FL_ENCODING | \ 1243 + EXT4_TUNE_FL_ENCODING_FLAGS) 1244 + 1245 + #define EXT4_TUNE_SET_COMPAT_SUPP \ 1246 + (EXT4_FEATURE_COMPAT_DIR_INDEX | \ 1247 + EXT4_FEATURE_COMPAT_STABLE_INODES) 1248 + #define EXT4_TUNE_SET_INCOMPAT_SUPP \ 1249 + (EXT4_FEATURE_INCOMPAT_EXTENTS | \ 1250 + EXT4_FEATURE_INCOMPAT_EA_INODE | \ 1251 + EXT4_FEATURE_INCOMPAT_ENCRYPT | \ 1252 + EXT4_FEATURE_INCOMPAT_CSUM_SEED | \ 1253 + EXT4_FEATURE_INCOMPAT_LARGEDIR | \ 1254 + EXT4_FEATURE_INCOMPAT_CASEFOLD) 1255 + #define EXT4_TUNE_SET_RO_COMPAT_SUPP \ 1256 + (EXT4_FEATURE_RO_COMPAT_LARGE_FILE | \ 1257 + EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \ 1258 + EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE | \ 1259 + EXT4_FEATURE_RO_COMPAT_PROJECT | \ 1260 + EXT4_FEATURE_RO_COMPAT_VERITY) 1261 + 1262 + #define EXT4_TUNE_CLEAR_COMPAT_SUPP (0) 1263 + #define EXT4_TUNE_CLEAR_INCOMPAT_SUPP (0) 1264 + #define EXT4_TUNE_CLEAR_RO_COMPAT_SUPP (0) 1265 + 1266 + #define SB_ENC_SUPP_MASK (SB_ENC_STRICT_MODE_FL | \ 1267 + SB_ENC_NO_COMPAT_FALLBACK_FL) 1268 + 1269 + static int ext4_ioctl_get_tune_sb(struct ext4_sb_info *sbi, 1270 + struct ext4_tune_sb_params __user *params) 1271 + { 1272 + struct ext4_tune_sb_params ret; 1273 + struct ext4_super_block *es = sbi->s_es; 1274 + 1275 + memset(&ret, 0, sizeof(ret)); 1276 + ret.set_flags = TUNE_OPS_SUPPORTED; 1277 + ret.errors_behavior = le16_to_cpu(es->s_errors); 1278 + ret.mnt_count = le16_to_cpu(es->s_mnt_count); 1279 + ret.max_mnt_count = le16_to_cpu(es->s_max_mnt_count); 1280 + ret.checkinterval = le32_to_cpu(es->s_checkinterval); 1281 + ret.last_check_time = le32_to_cpu(es->s_lastcheck); 1282 + ret.reserved_blocks = ext4_r_blocks_count(es); 1283 + ret.blocks_count = ext4_blocks_count(es); 1284 + ret.reserved_uid = ext4_get_resuid(es); 1285 + ret.reserved_gid = ext4_get_resgid(es); 1286 + ret.default_mnt_opts = le32_to_cpu(es->s_default_mount_opts); 1287 + ret.def_hash_alg = es->s_def_hash_version; 1288 + ret.raid_stride = le16_to_cpu(es->s_raid_stride); 1289 + ret.raid_stripe_width = le32_to_cpu(es->s_raid_stripe_width); 1290 + ret.encoding = le16_to_cpu(es->s_encoding); 1291 + ret.encoding_flags = le16_to_cpu(es->s_encoding_flags); 1292 + strscpy_pad(ret.mount_opts, es->s_mount_opts); 1293 + ret.feature_compat = le32_to_cpu(es->s_feature_compat); 1294 + ret.feature_incompat = le32_to_cpu(es->s_feature_incompat); 1295 + ret.feature_ro_compat = le32_to_cpu(es->s_feature_ro_compat); 1296 + ret.set_feature_compat_mask = EXT4_TUNE_SET_COMPAT_SUPP; 1297 + ret.set_feature_incompat_mask = EXT4_TUNE_SET_INCOMPAT_SUPP; 1298 + ret.set_feature_ro_compat_mask = EXT4_TUNE_SET_RO_COMPAT_SUPP; 1299 + ret.clear_feature_compat_mask = EXT4_TUNE_CLEAR_COMPAT_SUPP; 1300 + ret.clear_feature_incompat_mask = EXT4_TUNE_CLEAR_INCOMPAT_SUPP; 1301 + ret.clear_feature_ro_compat_mask = EXT4_TUNE_CLEAR_RO_COMPAT_SUPP; 1302 + if (copy_to_user(params, &ret, sizeof(ret))) 1303 + return -EFAULT; 1304 + return 0; 1305 + } 1306 + 1307 + static void ext4_sb_setparams(struct ext4_sb_info *sbi, 1308 + struct ext4_super_block *es, const void *arg) 1309 + { 1310 + const struct ext4_tune_sb_params *params = arg; 1311 + 1312 + if (params->set_flags & EXT4_TUNE_FL_ERRORS_BEHAVIOR) 1313 + es->s_errors = cpu_to_le16(params->errors_behavior); 1314 + if (params->set_flags & EXT4_TUNE_FL_MNT_COUNT) 1315 + es->s_mnt_count = cpu_to_le16(params->mnt_count); 1316 + if (params->set_flags & EXT4_TUNE_FL_MAX_MNT_COUNT) 1317 + es->s_max_mnt_count = cpu_to_le16(params->max_mnt_count); 1318 + if (params->set_flags & EXT4_TUNE_FL_CHECKINTRVAL) 1319 + es->s_checkinterval = cpu_to_le32(params->checkinterval); 1320 + if (params->set_flags & EXT4_TUNE_FL_LAST_CHECK_TIME) 1321 + es->s_lastcheck = cpu_to_le32(params->last_check_time); 1322 + if (params->set_flags & EXT4_TUNE_FL_RESERVED_BLOCKS) { 1323 + ext4_fsblk_t blk = params->reserved_blocks; 1324 + 1325 + es->s_r_blocks_count_lo = cpu_to_le32((u32)blk); 1326 + es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32); 1327 + } 1328 + if (params->set_flags & EXT4_TUNE_FL_RESERVED_UID) { 1329 + int uid = params->reserved_uid; 1330 + 1331 + es->s_def_resuid = cpu_to_le16(uid & 0xFFFF); 1332 + es->s_def_resuid_hi = cpu_to_le16(uid >> 16); 1333 + } 1334 + if (params->set_flags & EXT4_TUNE_FL_RESERVED_GID) { 1335 + int gid = params->reserved_gid; 1336 + 1337 + es->s_def_resgid = cpu_to_le16(gid & 0xFFFF); 1338 + es->s_def_resgid_hi = cpu_to_le16(gid >> 16); 1339 + } 1340 + if (params->set_flags & EXT4_TUNE_FL_DEFAULT_MNT_OPTS) 1341 + es->s_default_mount_opts = cpu_to_le32(params->default_mnt_opts); 1342 + if (params->set_flags & EXT4_TUNE_FL_DEF_HASH_ALG) 1343 + es->s_def_hash_version = params->def_hash_alg; 1344 + if (params->set_flags & EXT4_TUNE_FL_RAID_STRIDE) 1345 + es->s_raid_stride = cpu_to_le16(params->raid_stride); 1346 + if (params->set_flags & EXT4_TUNE_FL_RAID_STRIPE_WIDTH) 1347 + es->s_raid_stripe_width = 1348 + cpu_to_le32(params->raid_stripe_width); 1349 + if (params->set_flags & EXT4_TUNE_FL_ENCODING) 1350 + es->s_encoding = cpu_to_le16(params->encoding); 1351 + if (params->set_flags & EXT4_TUNE_FL_ENCODING_FLAGS) 1352 + es->s_encoding_flags = cpu_to_le16(params->encoding_flags); 1353 + strscpy_pad(es->s_mount_opts, params->mount_opts); 1354 + if (params->set_flags & EXT4_TUNE_FL_EDIT_FEATURES) { 1355 + es->s_feature_compat |= 1356 + cpu_to_le32(params->set_feature_compat_mask); 1357 + es->s_feature_incompat |= 1358 + cpu_to_le32(params->set_feature_incompat_mask); 1359 + es->s_feature_ro_compat |= 1360 + cpu_to_le32(params->set_feature_ro_compat_mask); 1361 + es->s_feature_compat &= 1362 + ~cpu_to_le32(params->clear_feature_compat_mask); 1363 + es->s_feature_incompat &= 1364 + ~cpu_to_le32(params->clear_feature_incompat_mask); 1365 + es->s_feature_ro_compat &= 1366 + ~cpu_to_le32(params->clear_feature_ro_compat_mask); 1367 + if (params->set_feature_compat_mask & 1368 + EXT4_FEATURE_COMPAT_DIR_INDEX) 1369 + es->s_def_hash_version = sbi->s_def_hash_version; 1370 + if (params->set_feature_incompat_mask & 1371 + EXT4_FEATURE_INCOMPAT_CSUM_SEED) 1372 + es->s_checksum_seed = cpu_to_le32(sbi->s_csum_seed); 1373 + } 1374 + if (params->set_flags & EXT4_TUNE_FL_FORCE_FSCK) 1375 + es->s_state |= cpu_to_le16(EXT4_ERROR_FS); 1376 + } 1377 + 1378 + static int ext4_ioctl_set_tune_sb(struct file *filp, 1379 + struct ext4_tune_sb_params __user *in) 1380 + { 1381 + struct ext4_tune_sb_params params; 1382 + struct super_block *sb = file_inode(filp)->i_sb; 1383 + struct ext4_sb_info *sbi = EXT4_SB(sb); 1384 + struct ext4_super_block *es = sbi->s_es; 1385 + int enabling_casefold = 0; 1386 + int ret; 1387 + 1388 + if (!capable(CAP_SYS_ADMIN)) 1389 + return -EPERM; 1390 + 1391 + if (copy_from_user(&params, in, sizeof(params))) 1392 + return -EFAULT; 1393 + 1394 + if ((params.set_flags & ~TUNE_OPS_SUPPORTED) != 0) 1395 + return -EOPNOTSUPP; 1396 + 1397 + if ((params.set_flags & EXT4_TUNE_FL_ERRORS_BEHAVIOR) && 1398 + (params.errors_behavior > EXT4_ERRORS_PANIC)) 1399 + return -EINVAL; 1400 + 1401 + if ((params.set_flags & EXT4_TUNE_FL_RESERVED_BLOCKS) && 1402 + (params.reserved_blocks > ext4_blocks_count(sbi->s_es) / 2)) 1403 + return -EINVAL; 1404 + if ((params.set_flags & EXT4_TUNE_FL_DEF_HASH_ALG) && 1405 + ((params.def_hash_alg > DX_HASH_LAST) || 1406 + (params.def_hash_alg == DX_HASH_SIPHASH))) 1407 + return -EINVAL; 1408 + if ((params.set_flags & EXT4_TUNE_FL_FEATURES) && 1409 + (params.set_flags & EXT4_TUNE_FL_EDIT_FEATURES)) 1410 + return -EINVAL; 1411 + 1412 + if (params.set_flags & EXT4_TUNE_FL_FEATURES) { 1413 + params.set_feature_compat_mask = 1414 + params.feature_compat & 1415 + ~le32_to_cpu(es->s_feature_compat); 1416 + params.set_feature_incompat_mask = 1417 + params.feature_incompat & 1418 + ~le32_to_cpu(es->s_feature_incompat); 1419 + params.set_feature_ro_compat_mask = 1420 + params.feature_ro_compat & 1421 + ~le32_to_cpu(es->s_feature_ro_compat); 1422 + params.clear_feature_compat_mask = 1423 + ~params.feature_compat & 1424 + le32_to_cpu(es->s_feature_compat); 1425 + params.clear_feature_incompat_mask = 1426 + ~params.feature_incompat & 1427 + le32_to_cpu(es->s_feature_incompat); 1428 + params.clear_feature_ro_compat_mask = 1429 + ~params.feature_ro_compat & 1430 + le32_to_cpu(es->s_feature_ro_compat); 1431 + params.set_flags |= EXT4_TUNE_FL_EDIT_FEATURES; 1432 + } 1433 + if (params.set_flags & EXT4_TUNE_FL_EDIT_FEATURES) { 1434 + if ((params.set_feature_compat_mask & 1435 + ~EXT4_TUNE_SET_COMPAT_SUPP) || 1436 + (params.set_feature_incompat_mask & 1437 + ~EXT4_TUNE_SET_INCOMPAT_SUPP) || 1438 + (params.set_feature_ro_compat_mask & 1439 + ~EXT4_TUNE_SET_RO_COMPAT_SUPP) || 1440 + (params.clear_feature_compat_mask & 1441 + ~EXT4_TUNE_CLEAR_COMPAT_SUPP) || 1442 + (params.clear_feature_incompat_mask & 1443 + ~EXT4_TUNE_CLEAR_INCOMPAT_SUPP) || 1444 + (params.clear_feature_ro_compat_mask & 1445 + ~EXT4_TUNE_CLEAR_RO_COMPAT_SUPP)) 1446 + return -EOPNOTSUPP; 1447 + 1448 + /* 1449 + * Filter out the features that are already set from 1450 + * the set_mask. 1451 + */ 1452 + params.set_feature_compat_mask &= 1453 + ~le32_to_cpu(es->s_feature_compat); 1454 + params.set_feature_incompat_mask &= 1455 + ~le32_to_cpu(es->s_feature_incompat); 1456 + params.set_feature_ro_compat_mask &= 1457 + ~le32_to_cpu(es->s_feature_ro_compat); 1458 + if ((params.set_feature_incompat_mask & 1459 + EXT4_FEATURE_INCOMPAT_CASEFOLD)) { 1460 + enabling_casefold = 1; 1461 + if (!(params.set_flags & EXT4_TUNE_FL_ENCODING)) { 1462 + params.encoding = EXT4_ENC_UTF8_12_1; 1463 + params.set_flags |= EXT4_TUNE_FL_ENCODING; 1464 + } 1465 + if (!(params.set_flags & EXT4_TUNE_FL_ENCODING_FLAGS)) { 1466 + params.encoding_flags = 0; 1467 + params.set_flags |= EXT4_TUNE_FL_ENCODING_FLAGS; 1468 + } 1469 + } 1470 + if ((params.set_feature_compat_mask & 1471 + EXT4_FEATURE_COMPAT_DIR_INDEX)) { 1472 + uuid_t uu; 1473 + 1474 + memcpy(&uu, sbi->s_hash_seed, UUID_SIZE); 1475 + if (uuid_is_null(&uu)) 1476 + generate_random_uuid((char *) 1477 + &sbi->s_hash_seed); 1478 + if (params.set_flags & EXT4_TUNE_FL_DEF_HASH_ALG) 1479 + sbi->s_def_hash_version = params.def_hash_alg; 1480 + else if (sbi->s_def_hash_version == 0) 1481 + sbi->s_def_hash_version = DX_HASH_HALF_MD4; 1482 + if (!(es->s_flags & 1483 + cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH)) && 1484 + !(es->s_flags & 1485 + cpu_to_le32(EXT2_FLAGS_SIGNED_HASH))) { 1486 + #ifdef __CHAR_UNSIGNED__ 1487 + sbi->s_hash_unsigned = 3; 1488 + #else 1489 + sbi->s_hash_unsigned = 0; 1490 + #endif 1491 + } 1492 + } 1493 + } 1494 + if (params.set_flags & EXT4_TUNE_FL_ENCODING) { 1495 + if (!enabling_casefold) 1496 + return -EINVAL; 1497 + if (params.encoding == 0) 1498 + params.encoding = EXT4_ENC_UTF8_12_1; 1499 + else if (params.encoding != EXT4_ENC_UTF8_12_1) 1500 + return -EINVAL; 1501 + } 1502 + if (params.set_flags & EXT4_TUNE_FL_ENCODING_FLAGS) { 1503 + if (!enabling_casefold) 1504 + return -EINVAL; 1505 + if (params.encoding_flags & ~SB_ENC_SUPP_MASK) 1506 + return -EINVAL; 1507 + } 1508 + 1509 + ret = mnt_want_write_file(filp); 1510 + if (ret) 1511 + return ret; 1512 + 1513 + ret = ext4_update_superblocks_fn(sb, ext4_sb_setparams, &params); 1514 + mnt_drop_write_file(filp); 1515 + 1516 + if (params.set_flags & EXT4_TUNE_FL_DEF_HASH_ALG) 1517 + sbi->s_def_hash_version = params.def_hash_alg; 1518 + 1519 + return ret; 1520 + } 1521 + 1236 1522 static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 1237 1523 { 1238 1524 struct inode *inode = file_inode(filp); ··· 1908 1616 return ext4_ioctl_getuuid(EXT4_SB(sb), (void __user *)arg); 1909 1617 case EXT4_IOC_SETFSUUID: 1910 1618 return ext4_ioctl_setuuid(filp, (const void __user *)arg); 1619 + case EXT4_IOC_GET_TUNE_SB_PARAM: 1620 + return ext4_ioctl_get_tune_sb(EXT4_SB(sb), 1621 + (void __user *)arg); 1622 + case EXT4_IOC_SET_TUNE_SB_PARAM: 1623 + return ext4_ioctl_set_tune_sb(filp, (void __user *)arg); 1911 1624 default: 1912 1625 return -ENOTTY; 1913 1626 } ··· 2000 1703 } 2001 1704 #endif 2002 1705 2003 - static void set_overhead(struct ext4_super_block *es, const void *arg) 1706 + static void set_overhead(struct ext4_sb_info *sbi, 1707 + struct ext4_super_block *es, const void *arg) 2004 1708 { 2005 1709 es->s_overhead_clusters = cpu_to_le32(*((unsigned long *) arg)); 2006 1710 }
+53
include/uapi/linux/ext4.h
··· 33 33 #define EXT4_IOC_CHECKPOINT _IOW('f', 43, __u32) 34 34 #define EXT4_IOC_GETFSUUID _IOR('f', 44, struct fsuuid) 35 35 #define EXT4_IOC_SETFSUUID _IOW('f', 44, struct fsuuid) 36 + #define EXT4_IOC_GET_TUNE_SB_PARAM _IOR('f', 45, struct ext4_tune_sb_params) 37 + #define EXT4_IOC_SET_TUNE_SB_PARAM _IOW('f', 46, struct ext4_tune_sb_params) 36 38 37 39 #define EXT4_IOC_SHUTDOWN _IOR('X', 125, __u32) 38 40 ··· 109 107 __u16 reserved_blocks; /* Number of reserved blocks in this group */ 110 108 __u16 unused; 111 109 }; 110 + 111 + struct ext4_tune_sb_params { 112 + __u32 set_flags; 113 + __u32 checkinterval; 114 + __u16 errors_behavior; 115 + __u16 mnt_count; 116 + __u16 max_mnt_count; 117 + __u16 raid_stride; 118 + __u64 last_check_time; 119 + __u64 reserved_blocks; 120 + __u64 blocks_count; 121 + __u32 default_mnt_opts; 122 + __u32 reserved_uid; 123 + __u32 reserved_gid; 124 + __u32 raid_stripe_width; 125 + __u16 encoding; 126 + __u16 encoding_flags; 127 + __u8 def_hash_alg; 128 + __u8 pad_1; 129 + __u16 pad_2; 130 + __u32 feature_compat; 131 + __u32 feature_incompat; 132 + __u32 feature_ro_compat; 133 + __u32 set_feature_compat_mask; 134 + __u32 set_feature_incompat_mask; 135 + __u32 set_feature_ro_compat_mask; 136 + __u32 clear_feature_compat_mask; 137 + __u32 clear_feature_incompat_mask; 138 + __u32 clear_feature_ro_compat_mask; 139 + __u8 mount_opts[64]; 140 + __u8 pad[64]; 141 + }; 142 + 143 + #define EXT4_TUNE_FL_ERRORS_BEHAVIOR 0x00000001 144 + #define EXT4_TUNE_FL_MNT_COUNT 0x00000002 145 + #define EXT4_TUNE_FL_MAX_MNT_COUNT 0x00000004 146 + #define EXT4_TUNE_FL_CHECKINTRVAL 0x00000008 147 + #define EXT4_TUNE_FL_LAST_CHECK_TIME 0x00000010 148 + #define EXT4_TUNE_FL_RESERVED_BLOCKS 0x00000020 149 + #define EXT4_TUNE_FL_RESERVED_UID 0x00000040 150 + #define EXT4_TUNE_FL_RESERVED_GID 0x00000080 151 + #define EXT4_TUNE_FL_DEFAULT_MNT_OPTS 0x00000100 152 + #define EXT4_TUNE_FL_DEF_HASH_ALG 0x00000200 153 + #define EXT4_TUNE_FL_RAID_STRIDE 0x00000400 154 + #define EXT4_TUNE_FL_RAID_STRIPE_WIDTH 0x00000800 155 + #define EXT4_TUNE_FL_MOUNT_OPTS 0x00001000 156 + #define EXT4_TUNE_FL_FEATURES 0x00002000 157 + #define EXT4_TUNE_FL_EDIT_FEATURES 0x00004000 158 + #define EXT4_TUNE_FL_FORCE_FSCK 0x00008000 159 + #define EXT4_TUNE_FL_ENCODING 0x00010000 160 + #define EXT4_TUNE_FL_ENCODING_FLAGS 0x00020000 112 161 113 162 /* 114 163 * Returned by EXT4_IOC_GET_ES_CACHE as an additional possible flag.