[thirdparty/e2fsprogs.git] / lib / e2p / ls.c

/*
 * ls.c			- List the contents of an ext2fs superblock
 *
 * Copyright (C) 1992, 1993, 1994  Remy Card <card@masi.ibp.fr>
 *                                 Laboratoire MASI, Institut Blaise Pascal
 *                                 Universite Pierre et Marie Curie (Paris VI)
 *
 * Copyright (C) 1995, 1996, 1997  Theodore Ts'o <tytso@mit.edu>
 *
 * %Begin-Header%
 * This file may be redistributed under the terms of the GNU Library
 * General Public License, version 2.
 * %End-Header%
 */

#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <grp.h>
#include <pwd.h>
#include <time.h>

#include "e2p.h"
#include "support/quotaio.h"

static void print_user (unsigned short uid, FILE *f)
{
	struct passwd *pw;

	fprintf(f, "%u ", uid);
	pw = getpwuid (uid);
	if (pw == NULL)
		fprintf(f, "(user unknown)\n");
	else
		fprintf(f, "(user %s)\n", pw->pw_name);
}

static void print_group (unsigned short gid, FILE *f)
{
	struct group *gr;

	fprintf(f, "%u ", gid);
	gr = getgrgid (gid);
	if (gr == NULL)
		fprintf(f, "(group unknown)\n");
	else
		fprintf(f, "(group %s)\n", gr->gr_name);
}

#define MONTH_INT (86400 * 30)
#define WEEK_INT (86400 * 7)
#define DAY_INT	(86400)
#define HOUR_INT (60 * 60)
#define MINUTE_INT (60)

static const char *interval_string(unsigned int secs)
{
	static char buf[256], tmp[80];
	int		hr, min, num;

	buf[0] = 0;

	if (secs == 0)
		return "<none>";

	if (secs >= MONTH_INT) {
		num = secs / MONTH_INT;
		secs -= num*MONTH_INT;
		sprintf(buf, "%d month%s", num, (num>1) ? "s" : "");
	}
	if (secs >= WEEK_INT) {
		num = secs / WEEK_INT;
		secs -= num*WEEK_INT;
		sprintf(tmp, "%s%d week%s", buf[0] ? ", " : "",
			num, (num>1) ? "s" : "");
		strcat(buf, tmp);
	}
	if (secs >= DAY_INT) {
		num = secs / DAY_INT;
		secs -= num*DAY_INT;
		sprintf(tmp, "%s%d day%s", buf[0] ? ", " : "",
			num, (num>1) ? "s" : "");
		strcat(buf, tmp);
	}
	if (secs > 0) {
		hr = secs / HOUR_INT;
		secs -= hr*HOUR_INT;
		min = secs / MINUTE_INT;
		secs -= min*MINUTE_INT;
		sprintf(tmp, "%s%d:%02d:%02d", buf[0] ? ", " : "",
			hr, min, secs);
		strcat(buf, tmp);
	}
	return buf;
}

static void print_features(struct ext2_super_block * s, FILE *f)
{
#ifdef EXT2_DYNAMIC_REV
	int	i, j, printed=0;
	__u32	*mask = &s->s_feature_compat, m;

	fprintf(f, "Filesystem features:     ");
	for (i=0; i <3; i++,mask++) {
		for (j=0,m=1; j < 32; j++, m<<=1) {
			if (*mask & m) {
				fprintf(f, " %s", e2p_feature2string(i, m));
				printed++;
			}
		}
	}
	if (printed == 0)
		fprintf(f, " (none)");
	fprintf(f, "\n");
#endif
}

static void print_mntopts(struct ext2_super_block * s, FILE *f)
{
#ifdef EXT2_DYNAMIC_REV
	int	i, printed=0;
	__u32	mask = s->s_default_mount_opts, m;

	fprintf(f, "Default mount options:   ");
	if (mask & EXT3_DEFM_JMODE) {
		fprintf(f, " %s", e2p_mntopt2string(mask & EXT3_DEFM_JMODE));
		printed++;
	}
	for (i=0,m=1; i < 32; i++, m<<=1) {
		if (m & EXT3_DEFM_JMODE)
			continue;
		if (mask & m) {
			fprintf(f, " %s", e2p_mntopt2string(m));
			printed++;
		}
	}
	if (printed == 0)
		fprintf(f, " (none)");
	fprintf(f, "\n");
#endif
}

static void print_super_flags(struct ext2_super_block * s, FILE *f)
{
	int	flags_found = 0;

	if (s->s_flags == 0)
		return;

	fputs("Filesystem flags:         ", f);
	if (s->s_flags & EXT2_FLAGS_SIGNED_HASH) {
		fputs("signed_directory_hash ", f);
		flags_found++;
	}
	if (s->s_flags & EXT2_FLAGS_UNSIGNED_HASH) {
		fputs("unsigned_directory_hash ", f);
		flags_found++;
	}
	if (s->s_flags & EXT2_FLAGS_TEST_FILESYS) {
		fputs("test_filesystem ", f);
		flags_found++;
	}
	if (flags_found)
		fputs("\n", f);
	else
		fputs("(none)\n", f);
}

static __u64 e2p_blocks_count(struct ext2_super_block *super)
{
	return super->s_blocks_count |
		(ext2fs_has_feature_64bit(super) ?
		(__u64) super->s_blocks_count_hi << 32 : 0);
}

static __u64 e2p_r_blocks_count(struct ext2_super_block *super)
{
	return super->s_r_blocks_count |
		(ext2fs_has_feature_64bit(super) ?
		(__u64) super->s_r_blocks_count_hi << 32 : 0);
}

static __u64 e2p_free_blocks_count(struct ext2_super_block *super)
{
	return super->s_free_blocks_count |
		(ext2fs_has_feature_64bit(super) ?
		(__u64) super->s_free_blocks_hi << 32 : 0);
}

#ifndef EXT2_INODE_SIZE
#define EXT2_INODE_SIZE(s) sizeof(struct ext2_inode)
#endif

#ifndef EXT2_GOOD_OLD_REV
#define EXT2_GOOD_OLD_REV 0
#endif

static const char *checksum_type(__u8 type)
{
	switch (type) {
	case EXT2_CRC32C_CHKSUM:
		return "crc32c";
	default:
		return "unknown";
	}
}

static const char *quota_prefix[MAXQUOTAS] = {
	[USRQUOTA] = "User quota inode:",
	[GRPQUOTA] = "Group quota inode:",
	[PRJQUOTA] = "Project quota inode:",
};

/**
 * Convert type of quota to written representation
 */
static const char *quota_type2prefix(enum quota_type qtype)
{
	return quota_prefix[qtype];
}

void list_super2(struct ext2_super_block * sb, FILE *f)
{
	int inode_blocks_per_group;
	char buf[80], *str;
	time_t	tm;
	enum quota_type qtype;

	inode_blocks_per_group = (((sb->s_inodes_per_group *
				    EXT2_INODE_SIZE(sb)) +
				   EXT2_BLOCK_SIZE(sb) - 1) /
				  EXT2_BLOCK_SIZE(sb));
	if (sb->s_volume_name[0]) {
		memset(buf, 0, sizeof(buf));
		strncpy(buf, sb->s_volume_name, sizeof(sb->s_volume_name));
	} else
		strcpy(buf, "<none>");
	fprintf(f, "Filesystem volume name:   %s\n", buf);
	if (sb->s_last_mounted[0]) {
		memset(buf, 0, sizeof(buf));
		strncpy(buf, sb->s_last_mounted, sizeof(sb->s_last_mounted));
	} else
		strcpy(buf, "<not available>");
	fprintf(f, "Last mounted on:          %s\n", buf);
	fprintf(f, "Filesystem UUID:          %s\n", e2p_uuid2str(sb->s_uuid));
	fprintf(f, "Filesystem magic number:  0x%04X\n", sb->s_magic);
	fprintf(f, "Filesystem revision #:    %d", sb->s_rev_level);
	if (sb->s_rev_level == EXT2_GOOD_OLD_REV) {
		fprintf(f, " (original)\n");
#ifdef EXT2_DYNAMIC_REV
	} else if (sb->s_rev_level == EXT2_DYNAMIC_REV) {
		fprintf(f, " (dynamic)\n");
#endif
	} else
		fprintf(f, " (unknown)\n");
	print_features(sb, f);
	print_super_flags(sb, f);
	print_mntopts(sb, f);
	if (sb->s_mount_opts[0])
		fprintf(f, "Mount options:            %s\n", sb->s_mount_opts);
	fprintf(f, "Filesystem state:        ");
	print_fs_state (f, sb->s_state);
	fprintf(f, "\n");
	fprintf(f, "Errors behavior:          ");
	print_fs_errors(f, sb->s_errors);
	fprintf(f, "\n");
	str = e2p_os2string(sb->s_creator_os);
	fprintf(f, "Filesystem OS type:       %s\n", str);
	free(str);
	fprintf(f, "Inode count:              %u\n", sb->s_inodes_count);
	fprintf(f, "Block count:              %llu\n", e2p_blocks_count(sb));
	fprintf(f, "Reserved block count:     %llu\n", e2p_r_blocks_count(sb));
	if (sb->s_overhead_blocks)
		fprintf(f, "Overhead blocks:          %u\n",
			sb->s_overhead_blocks);
	fprintf(f, "Free blocks:              %llu\n", e2p_free_blocks_count(sb));
	fprintf(f, "Free inodes:              %u\n", sb->s_free_inodes_count);
	fprintf(f, "First block:              %u\n", sb->s_first_data_block);
	fprintf(f, "Block size:               %u\n", EXT2_BLOCK_SIZE(sb));
	if (ext2fs_has_feature_bigalloc(sb))
		fprintf(f, "Cluster size:             %u\n",
			EXT2_CLUSTER_SIZE(sb));
	else
		fprintf(f, "Fragment size:            %u\n",
			EXT2_CLUSTER_SIZE(sb));
	if (ext2fs_has_feature_64bit(sb))
		fprintf(f, "Group descriptor size:    %u\n", sb->s_desc_size);
	if (sb->s_reserved_gdt_blocks)
		fprintf(f, "Reserved GDT blocks:      %u\n",
			sb->s_reserved_gdt_blocks);
	fprintf(f, "Blocks per group:         %u\n", sb->s_blocks_per_group);
	if (ext2fs_has_feature_bigalloc(sb))
		fprintf(f, "Clusters per group:       %u\n",
			sb->s_clusters_per_group);
	else
		fprintf(f, "Fragments per group:      %u\n",
			sb->s_clusters_per_group);
	fprintf(f, "Inodes per group:         %u\n", sb->s_inodes_per_group);
	fprintf(f, "Inode blocks per group:   %u\n", inode_blocks_per_group);
	if (sb->s_raid_stride)
		fprintf(f, "RAID stride:              %u\n",
			sb->s_raid_stride);
	if (sb->s_raid_stripe_width)
		fprintf(f, "RAID stripe width:        %u\n",
			sb->s_raid_stripe_width);
	if (sb->s_first_meta_bg)
		fprintf(f, "First meta block group:   %u\n",
			sb->s_first_meta_bg);
	if (sb->s_log_groups_per_flex)
		fprintf(f, "Flex block group size:    %u\n",
			1 << sb->s_log_groups_per_flex);
	if (sb->s_mkfs_time) {
		tm = sb->s_mkfs_time;
		fprintf(f, "Filesystem created:       %s", ctime(&tm));
	}
	tm = sb->s_mtime;
	fprintf(f, "Last mount time:          %s",
		sb->s_mtime ? ctime(&tm) : "n/a\n");
	tm = sb->s_wtime;
	fprintf(f, "Last write time:          %s", ctime(&tm));
	fprintf(f, "Mount count:              %u\n", sb->s_mnt_count);
	fprintf(f, "Maximum mount count:      %d\n", sb->s_max_mnt_count);
	tm = sb->s_lastcheck;
	fprintf(f, "Last checked:             %s", ctime(&tm));
	fprintf(f, "Check interval:           %u (%s)\n", sb->s_checkinterval,
	       interval_string(sb->s_checkinterval));
	if (sb->s_checkinterval)
	{
		time_t next;

		next = sb->s_lastcheck + sb->s_checkinterval;
		fprintf(f, "Next check after:         %s", ctime(&next));
	}
#define POW2(x) ((__u64) 1 << (x))
	if (sb->s_kbytes_written) {
		fprintf(f, "Lifetime writes:          ");
		if (sb->s_kbytes_written < POW2(13))
			fprintf(f, "%llu kB\n", sb->s_kbytes_written);
		else if (sb->s_kbytes_written < POW2(23))
			fprintf(f, "%llu MB\n",
				(sb->s_kbytes_written + POW2(9)) >> 10);
		else if (sb->s_kbytes_written < POW2(33))
			fprintf(f, "%llu GB\n",
				(sb->s_kbytes_written + POW2(19)) >> 20);
		else if (sb->s_kbytes_written < POW2(43))
			fprintf(f, "%llu TB\n",
				(sb->s_kbytes_written + POW2(29)) >> 30);
		else
			fprintf(f, "%llu PB\n",
				(sb->s_kbytes_written + POW2(39)) >> 40);
	}
	fprintf(f, "Reserved blocks uid:      ");
	print_user(sb->s_def_resuid, f);
	fprintf(f, "Reserved blocks gid:      ");
	print_group(sb->s_def_resgid, f);
	if (sb->s_rev_level >= EXT2_DYNAMIC_REV) {
		fprintf(f, "First inode:              %d\n", sb->s_first_ino);
		fprintf(f, "Inode size:	          %d\n", sb->s_inode_size);
		if (sb->s_min_extra_isize)
			fprintf(f, "Required extra isize:     %d\n",
				sb->s_min_extra_isize);
		if (sb->s_want_extra_isize)
			fprintf(f, "Desired extra isize:      %d\n",
				sb->s_want_extra_isize);
	}
	if (!e2p_is_null_uuid(sb->s_journal_uuid))
		fprintf(f, "Journal UUID:             %s\n",
			e2p_uuid2str(sb->s_journal_uuid));
	if (sb->s_journal_inum)
		fprintf(f, "Journal inode:            %u\n",
			sb->s_journal_inum);
	if (sb->s_journal_dev)
		fprintf(f, "Journal device:	          0x%04x\n",
			sb->s_journal_dev);
	if (sb->s_last_orphan)
		fprintf(f, "First orphan inode:       %u\n",
			sb->s_last_orphan);
	if (ext2fs_has_feature_dir_index(sb) ||
	    sb->s_def_hash_version)
		fprintf(f, "Default directory hash:   %s\n",
			e2p_hash2string(sb->s_def_hash_version));
	if (!e2p_is_null_uuid(sb->s_hash_seed))
		fprintf(f, "Directory Hash Seed:      %s\n",
			e2p_uuid2str(sb->s_hash_seed));
	if (sb->s_jnl_backup_type) {
		fprintf(f, "Journal backup:           ");
		switch (sb->s_jnl_backup_type) {
		case 1:
			fprintf(f, "inode blocks\n");
			break;
		default:
			fprintf(f, "type %u\n", sb->s_jnl_backup_type);
		}
	}
	if (sb->s_backup_bgs[0] || sb->s_backup_bgs[1]) {
		fprintf(f, "Backup block groups:      ");
		if (sb->s_backup_bgs[0])
			fprintf(f, "%u ", sb->s_backup_bgs[0]);
		if (sb->s_backup_bgs[1])
			fprintf(f, "%u ", sb->s_backup_bgs[1]);
		fputc('\n', f);
	}
	if (sb->s_snapshot_inum) {
		fprintf(f, "Snapshot inode:           %u\n",
			sb->s_snapshot_inum);
		fprintf(f, "Snapshot ID:              %u\n",
			sb->s_snapshot_id);
		fprintf(f, "Snapshot reserved blocks: %llu\n",
			sb->s_snapshot_r_blocks_count);
	}
	if (sb->s_snapshot_list)
		fprintf(f, "Snapshot list head:       %u\n",
			sb->s_snapshot_list);
	if (sb->s_error_count)
		fprintf(f, "FS Error count:           %u\n",
			sb->s_error_count);
	if (sb->s_first_error_time) {
		tm = sb->s_first_error_time;
		fprintf(f, "First error time:         %s", ctime(&tm));
		memset(buf, 0, sizeof(buf));
		strncpy(buf, (char *)sb->s_first_error_func,
			sizeof(sb->s_first_error_func));
		fprintf(f, "First error function:     %s\n", buf);
		fprintf(f, "First error line #:       %u\n",
			sb->s_first_error_line);
		fprintf(f, "First error inode #:      %u\n",
			sb->s_first_error_ino);
		fprintf(f, "First error block #:      %llu\n",
			sb->s_first_error_block);
	}
	if (sb->s_last_error_time) {
		tm = sb->s_last_error_time;
		fprintf(f, "Last error time:          %s", ctime(&tm));
		memset(buf, 0, sizeof(buf));
		strncpy(buf, (char *)sb->s_last_error_func,
			sizeof(sb->s_last_error_func));
		fprintf(f, "Last error function:      %s\n", buf);
		fprintf(f, "Last error line #:        %u\n",
			sb->s_last_error_line);
		fprintf(f, "Last error inode #:       %u\n",
			sb->s_last_error_ino);
		fprintf(f, "Last error block #:       %llu\n",
			sb->s_last_error_block);
	}
	if (ext2fs_has_feature_mmp(sb)) {
		fprintf(f, "MMP block number:         %llu\n",
			(long long)sb->s_mmp_block);
		fprintf(f, "MMP update interval:      %u\n",
			sb->s_mmp_update_interval);
	}
	for (qtype = 0; qtype < MAXQUOTAS; qtype++) {
		if (*quota_sb_inump(sb, qtype) != 0)
			fprintf(f, "%-26s%u\n",
				quota_type2prefix(qtype),
				*quota_sb_inump(sb, qtype));
	}

	if (ext2fs_has_feature_metadata_csum(sb)) {
		fprintf(f, "Checksum type:            %s\n",
			checksum_type(sb->s_checksum_type));
		fprintf(f, "Checksum:                 0x%08x\n",
			sb->s_checksum);
	}
	if (!e2p_is_null_uuid(sb->s_encrypt_pw_salt))
		fprintf(f, "Encryption PW Salt:       %s\n",
			e2p_uuid2str(sb->s_encrypt_pw_salt));

	if (ext2fs_has_feature_csum_seed(sb))
		fprintf(f, "Checksum seed:            0x%08x\n",
			sb->s_checksum_seed);
	if (ext2fs_has_feature_fname_encoding(sb))
		fprintf(f, "Character encoding:       %s\n",
			e2p_encoding2str(sb->s_encoding));
}

void list_super (struct ext2_super_block * s)
{
	list_super2(s, stdout);
}
Commit	Line	Data
3839e657 TT	1	/*
	2	* ls.c - List the contents of an ext2fs superblock
	3	*
	4	* Copyright (C) 1992, 1993, 1994 Remy Card <card@masi.ibp.fr>
	5	* Laboratoire MASI, Institut Blaise Pascal
	6	* Universite Pierre et Marie Curie (Paris VI)
	7	*
21c84b71	8	* Copyright (C) 1995, 1996, 1997 Theodore Ts'o <tytso@mit.edu>
efc6f628	9	*
543547a5 TT	10	* %Begin-Header%
	11	* This file may be redistributed under the terms of the GNU Library
	12	* General Public License, version 2.
	13	* %End-Header%
3839e657 TT	14	*/
3839e657 TT	15
d1154eb4	16	#include "config.h"
1e3472c5	17	#include <stdio.h>
b7e4eef3	18	#include <stdlib.h>
50e1e10f	19	#include <sys/types.h>
1e3472c5	20	#include <string.h>
f3db3566 TT	21	#include <grp.h>
f3db3566 TT	22	#include <pwd.h>
3839e657 TT	23	#include <time.h>
3839e657 TT	24
3839e657	25	#include "e2p.h"
2d2d799c	26	#include "support/quotaio.h"
3839e657	27
53d39550	28	static void print_user (unsigned short uid, FILE *f)
f3db3566 TT	29	{
	30	struct passwd *pw;
	31
53d39550	32	fprintf(f, "%u ", uid);
f3db3566 TT	33	pw = getpwuid (uid);
f3db3566 TT	34	if (pw == NULL)
53d39550	35	fprintf(f, "(user unknown)\n");
f3db3566	36	else
53d39550	37	fprintf(f, "(user %s)\n", pw->pw_name);
f3db3566 TT	38	}
f3db3566 TT	39
53d39550	40	static void print_group (unsigned short gid, FILE *f)
f3db3566 TT	41	{
	42	struct group *gr;
	43
53d39550	44	fprintf(f, "%u ", gid);
f3db3566 TT	45	gr = getgrgid (gid);
f3db3566 TT	46	if (gr == NULL)
53d39550	47	fprintf(f, "(group unknown)\n");
f3db3566	48	else
53d39550	49	fprintf(f, "(group %s)\n", gr->gr_name);
f3db3566 TT	50	}
f3db3566 TT	51
1e3472c5 TT	52	#define MONTH_INT (86400 * 30)
	53	#define WEEK_INT (86400 * 7)
	54	#define DAY_INT (86400)
	55	#define HOUR_INT (60 * 60)
	56	#define MINUTE_INT (60)
	57
21c84b71	58	static const char *interval_string(unsigned int secs)
1e3472c5 TT	59	{
	60	static char buf[256], tmp[80];
	61	int hr, min, num;
	62
	63	buf[0] = 0;
	64
21c84b71 TT	65	if (secs == 0)
	66	return "<none>";
	67
1e3472c5 TT	68	if (secs >= MONTH_INT) {
	69	num = secs / MONTH_INT;
	70	secs -= num*MONTH_INT;
	71	sprintf(buf, "%d month%s", num, (num>1) ? "s" : "");
	72	}
	73	if (secs >= WEEK_INT) {
	74	num = secs / WEEK_INT;
	75	secs -= num*WEEK_INT;
	76	sprintf(tmp, "%s%d week%s", buf[0] ? ", " : "",
	77	num, (num>1) ? "s" : "");
	78	strcat(buf, tmp);
	79	}
	80	if (secs >= DAY_INT) {
	81	num = secs / DAY_INT;
	82	secs -= num*DAY_INT;
	83	sprintf(tmp, "%s%d day%s", buf[0] ? ", " : "",
	84	num, (num>1) ? "s" : "");
	85	strcat(buf, tmp);
	86	}
	87	if (secs > 0) {
	88	hr = secs / HOUR_INT;
	89	secs -= hr*HOUR_INT;
	90	min = secs / MINUTE_INT;
	91	secs -= min*MINUTE_INT;
	92	sprintf(tmp, "%s%d:%02d:%02d", buf[0] ? ", " : "",
	93	hr, min, secs);
	94	strcat(buf, tmp);
	95	}
	96	return buf;
	97	}
	98
53d39550	99	static void print_features(struct ext2_super_block * s, FILE *f)
d7b701de TT	100	{
	101	#ifdef EXT2_DYNAMIC_REV
	102	int i, j, printed=0;
	103	__u32 *mask = &s->s_feature_compat, m;
	104
53d39550	105	fprintf(f, "Filesystem features: ");
d7b701de TT	106	for (i=0; i <3; i++,mask++) {
	107	for (j=0,m=1; j < 32; j++, m<<=1) {
	108	if (*mask & m) {
53d39550	109	fprintf(f, " %s", e2p_feature2string(i, m));
d7b701de TT	110	printed++;
	111	}
	112	}
	113	}
	114	if (printed == 0)
6d21621c	115	fprintf(f, " (none)");
53d39550	116	fprintf(f, "\n");
d7b701de TT	117	#endif
	118	}
	119
a0c3fd5e TT	120	static void print_mntopts(struct ext2_super_block * s, FILE *f)
	121	{
	122	#ifdef EXT2_DYNAMIC_REV
	123	int i, printed=0;
	124	__u32 mask = s->s_default_mount_opts, m;
	125
	126	fprintf(f, "Default mount options: ");
4a959fe6 TT	127	if (mask & EXT3_DEFM_JMODE) {
	128	fprintf(f, " %s", e2p_mntopt2string(mask & EXT3_DEFM_JMODE));
	129	printed++;
	130	}
a0c3fd5e	131	for (i=0,m=1; i < 32; i++, m<<=1) {
4a959fe6 TT	132	if (m & EXT3_DEFM_JMODE)
4a959fe6 TT	133	continue;
a0c3fd5e	134	if (mask & m) {
4a959fe6	135	fprintf(f, " %s", e2p_mntopt2string(m));
a0c3fd5e TT	136	printed++;
	137	}
	138	}
	139	if (printed == 0)
	140	fprintf(f, " (none)");
	141	fprintf(f, "\n");
	142	#endif
	143	}
d7b701de	144
f77704e4 TT	145	static void print_super_flags(struct ext2_super_block * s, FILE *f)
	146	{
	147	int flags_found = 0;
	148
	149	if (s->s_flags == 0)
	150	return;
	151
	152	fputs("Filesystem flags: ", f);
	153	if (s->s_flags & EXT2_FLAGS_SIGNED_HASH) {
6cb27404	154	fputs("signed_directory_hash ", f);
f77704e4 TT	155	flags_found++;
	156	}
	157	if (s->s_flags & EXT2_FLAGS_UNSIGNED_HASH) {
6cb27404 TT	158	fputs("unsigned_directory_hash ", f);
	159	flags_found++;
	160	}
	161	if (s->s_flags & EXT2_FLAGS_TEST_FILESYS) {
	162	fputs("test_filesystem ", f);
f77704e4 TT	163	flags_found++;
	164	}
	165	if (flags_found)
	166	fputs("\n", f);
	167	else
	168	fputs("(none)\n", f);
	169	}
	170
0180a05e TT	171	static __u64 e2p_blocks_count(struct ext2_super_block *super)
	172	{
	173	return super->s_blocks_count \|
77b3e987	174	(ext2fs_has_feature_64bit(super) ?
0180a05e TT	175	(__u64) super->s_blocks_count_hi << 32 : 0);
	176	}
	177
	178	static __u64 e2p_r_blocks_count(struct ext2_super_block *super)
	179	{
	180	return super->s_r_blocks_count \|
77b3e987	181	(ext2fs_has_feature_64bit(super) ?
0180a05e TT	182	(__u64) super->s_r_blocks_count_hi << 32 : 0);
	183	}
	184
	185	static __u64 e2p_free_blocks_count(struct ext2_super_block *super)
	186	{
	187	return super->s_free_blocks_count \|
77b3e987	188	(ext2fs_has_feature_64bit(super) ?
0180a05e TT	189	(__u64) super->s_free_blocks_hi << 32 : 0);
0180a05e TT	190	}
1e3472c5	191
7f88b043 TT	192	#ifndef EXT2_INODE_SIZE
	193	#define EXT2_INODE_SIZE(s) sizeof(struct ext2_inode)
	194	#endif
	195
a29f4d30 TT	196	#ifndef EXT2_GOOD_OLD_REV
	197	#define EXT2_GOOD_OLD_REV 0
	198	#endif
	199
1eedf3e5 DW	200	static const char *checksum_type(__u8 type)
	201	{
	202	switch (type) {
	203	case EXT2_CRC32C_CHKSUM:
	204	return "crc32c";
	205	default:
	206	return "unknown";
	207	}
	208	}
	209
2d2d799c LX	210	static const char *quota_prefix[MAXQUOTAS] = {
	211	[USRQUOTA] = "User quota inode:",
	212	[GRPQUOTA] = "Group quota inode:",
080e09b4	213	[PRJQUOTA] = "Project quota inode:",
2d2d799c LX	214	};
	215
	216	/**
	217	* Convert type of quota to written representation
	218	*/
	219	static const char *quota_type2prefix(enum quota_type qtype)
	220	{
	221	return quota_prefix[qtype];
	222	}
	223
379955fe	224	void list_super2(struct ext2_super_block * sb, FILE *f)
3839e657	225	{
7f88b043	226	int inode_blocks_per_group;
63253946	227	char buf[80], *str;
21c84b71	228	time_t tm;
2d2d799c	229	enum quota_type qtype;
7f88b043	230
379955fe TT	231	inode_blocks_per_group = (((sb->s_inodes_per_group *
	232	EXT2_INODE_SIZE(sb)) +
	233	EXT2_BLOCK_SIZE(sb) - 1) /
	234	EXT2_BLOCK_SIZE(sb));
1e3472c5 TT	235	if (sb->s_volume_name[0]) {
	236	memset(buf, 0, sizeof(buf));
	237	strncpy(buf, sb->s_volume_name, sizeof(sb->s_volume_name));
21c84b71 TT	238	} else
21c84b71 TT	239	strcpy(buf, "<none>");
53d39550	240	fprintf(f, "Filesystem volume name: %s\n", buf);
1e3472c5 TT	241	if (sb->s_last_mounted[0]) {
	242	memset(buf, 0, sizeof(buf));
	243	strncpy(buf, sb->s_last_mounted, sizeof(sb->s_last_mounted));
21c84b71 TT	244	} else
21c84b71 TT	245	strcpy(buf, "<not available>");
53d39550	246	fprintf(f, "Last mounted on: %s\n", buf);
f61fc0b5	247	fprintf(f, "Filesystem UUID: %s\n", e2p_uuid2str(sb->s_uuid));
379955fe TT	248	fprintf(f, "Filesystem magic number: 0x%04X\n", sb->s_magic);
	249	fprintf(f, "Filesystem revision #: %d", sb->s_rev_level);
	250	if (sb->s_rev_level == EXT2_GOOD_OLD_REV) {
53d39550	251	fprintf(f, " (original)\n");
521e3685	252	#ifdef EXT2_DYNAMIC_REV
379955fe	253	} else if (sb->s_rev_level == EXT2_DYNAMIC_REV) {
53d39550	254	fprintf(f, " (dynamic)\n");
521e3685 TT	255	#endif
521e3685 TT	256	} else
6d21621c	257	fprintf(f, " (unknown)\n");
379955fe	258	print_features(sb, f);
f77704e4	259	print_super_flags(sb, f);
a0c3fd5e	260	print_mntopts(sb, f);
9345f026 TT	261	if (sb->s_mount_opts[0])
9345f026 TT	262	fprintf(f, "Mount options: %s\n", sb->s_mount_opts);
53d39550	263	fprintf(f, "Filesystem state: ");
379955fe	264	print_fs_state (f, sb->s_state);
53d39550 TT	265	fprintf(f, "\n");
53d39550 TT	266	fprintf(f, "Errors behavior: ");
379955fe	267	print_fs_errors(f, sb->s_errors);
53d39550	268	fprintf(f, "\n");
63253946 TT	269	str = e2p_os2string(sb->s_creator_os);
	270	fprintf(f, "Filesystem OS type: %s\n", str);
	271	free(str);
379955fe	272	fprintf(f, "Inode count: %u\n", sb->s_inodes_count);
0180a05e TT	273	fprintf(f, "Block count: %llu\n", e2p_blocks_count(sb));
0180a05e TT	274	fprintf(f, "Reserved block count: %llu\n", e2p_r_blocks_count(sb));
4df16182 TT	275	if (sb->s_overhead_blocks)
	276	fprintf(f, "Overhead blocks: %u\n",
	277	sb->s_overhead_blocks);
0180a05e	278	fprintf(f, "Free blocks: %llu\n", e2p_free_blocks_count(sb));
379955fe TT	279	fprintf(f, "Free inodes: %u\n", sb->s_free_inodes_count);
	280	fprintf(f, "First block: %u\n", sb->s_first_data_block);
	281	fprintf(f, "Block size: %u\n", EXT2_BLOCK_SIZE(sb));
77b3e987	282	if (ext2fs_has_feature_bigalloc(sb))
412376ef TT	283	fprintf(f, "Cluster size: %u\n",
	284	EXT2_CLUSTER_SIZE(sb));
	285	else
	286	fprintf(f, "Fragment size: %u\n",
	287	EXT2_CLUSTER_SIZE(sb));
77b3e987	288	if (ext2fs_has_feature_64bit(sb))
11d1116a	289	fprintf(f, "Group descriptor size: %u\n", sb->s_desc_size);
faeaf937	290	if (sb->s_reserved_gdt_blocks)
efc6f628	291	fprintf(f, "Reserved GDT blocks: %u\n",
faeaf937	292	sb->s_reserved_gdt_blocks);
379955fe	293	fprintf(f, "Blocks per group: %u\n", sb->s_blocks_per_group);
77b3e987	294	if (ext2fs_has_feature_bigalloc(sb))
412376ef TT	295	fprintf(f, "Clusters per group: %u\n",
	296	sb->s_clusters_per_group);
	297	else
	298	fprintf(f, "Fragments per group: %u\n",
	299	sb->s_clusters_per_group);
379955fe	300	fprintf(f, "Inodes per group: %u\n", sb->s_inodes_per_group);
53d39550	301	fprintf(f, "Inode blocks per group: %u\n", inode_blocks_per_group);
6b226c3d	302	if (sb->s_raid_stride)
395529bb	303	fprintf(f, "RAID stride: %u\n",
6b226c3d TT	304	sb->s_raid_stride);
6b226c3d TT	305	if (sb->s_raid_stripe_width)
395529bb	306	fprintf(f, "RAID stripe width: %u\n",
6b226c3d	307	sb->s_raid_stripe_width);
c046ac7f TT	308	if (sb->s_first_meta_bg)
	309	fprintf(f, "First meta block group: %u\n",
	310	sb->s_first_meta_bg);
494a1daa TT	311	if (sb->s_log_groups_per_flex)
	312	fprintf(f, "Flex block group size: %u\n",
	313	1 << sb->s_log_groups_per_flex);
9d2aefb3 TT	314	if (sb->s_mkfs_time) {
	315	tm = sb->s_mkfs_time;
	316	fprintf(f, "Filesystem created: %s", ctime(&tm));
	317	}
	318	tm = sb->s_mtime;
	319	fprintf(f, "Last mount time: %s",
	320	sb->s_mtime ? ctime(&tm) : "n/a\n");
379955fe	321	tm = sb->s_wtime;
53d39550	322	fprintf(f, "Last write time: %s", ctime(&tm));
379955fe TT	323	fprintf(f, "Mount count: %u\n", sb->s_mnt_count);
	324	fprintf(f, "Maximum mount count: %d\n", sb->s_max_mnt_count);
	325	tm = sb->s_lastcheck;
53d39550	326	fprintf(f, "Last checked: %s", ctime(&tm));
379955fe TT	327	fprintf(f, "Check interval: %u (%s)\n", sb->s_checkinterval,
	328	interval_string(sb->s_checkinterval));
	329	if (sb->s_checkinterval)
3839e657 TT	330	{
	331	time_t next;
	332
379955fe	333	next = sb->s_lastcheck + sb->s_checkinterval;
53d39550	334	fprintf(f, "Next check after: %s", ctime(&next));
3839e657	335	}
b7c5b403 TT	336	#define POW2(x) ((__u64) 1 << (x))
	337	if (sb->s_kbytes_written) {
	338	fprintf(f, "Lifetime writes: ");
	339	if (sb->s_kbytes_written < POW2(13))
	340	fprintf(f, "%llu kB\n", sb->s_kbytes_written);
	341	else if (sb->s_kbytes_written < POW2(23))
	342	fprintf(f, "%llu MB\n",
	343	(sb->s_kbytes_written + POW2(9)) >> 10);
	344	else if (sb->s_kbytes_written < POW2(33))
	345	fprintf(f, "%llu GB\n",
	346	(sb->s_kbytes_written + POW2(19)) >> 20);
	347	else if (sb->s_kbytes_written < POW2(43))
	348	fprintf(f, "%llu TB\n",
	349	(sb->s_kbytes_written + POW2(29)) >> 30);
	350	else
	351	fprintf(f, "%llu PB\n",
	352	(sb->s_kbytes_written + POW2(39)) >> 40);
	353	}
53d39550	354	fprintf(f, "Reserved blocks uid: ");
379955fe	355	print_user(sb->s_def_resuid, f);
53d39550	356	fprintf(f, "Reserved blocks gid: ");
379955fe TT	357	print_group(sb->s_def_resgid, f);
	358	if (sb->s_rev_level >= EXT2_DYNAMIC_REV) {
	359	fprintf(f, "First inode: %d\n", sb->s_first_ino);
41a5afa8 TT	360	fprintf(f, "Inode size: %d\n", sb->s_inode_size);
41a5afa8 TT	361	if (sb->s_min_extra_isize)
efc6f628	362	fprintf(f, "Required extra isize: %d\n",
41a5afa8 TT	363	sb->s_min_extra_isize);
41a5afa8 TT	364	if (sb->s_want_extra_isize)
efc6f628	365	fprintf(f, "Desired extra isize: %d\n",
41a5afa8	366	sb->s_want_extra_isize);
7f88b043	367	}
9522e0aa	368	if (!e2p_is_null_uuid(sb->s_journal_uuid))
f61fc0b5 TT	369	fprintf(f, "Journal UUID: %s\n",
f61fc0b5 TT	370	e2p_uuid2str(sb->s_journal_uuid));
9522e0aa TT	371	if (sb->s_journal_inum)
	372	fprintf(f, "Journal inode: %u\n",
	373	sb->s_journal_inum);
	374	if (sb->s_journal_dev)
	375	fprintf(f, "Journal device: 0x%04x\n",
	376	sb->s_journal_dev);
	377	if (sb->s_last_orphan)
	378	fprintf(f, "First orphan inode: %u\n",
	379	sb->s_last_orphan);
77b3e987	380	if (ext2fs_has_feature_dir_index(sb) \|\|
9522e0aa	381	sb->s_def_hash_version)
f61fc0b5 TT	382	fprintf(f, "Default directory hash: %s\n",
f61fc0b5 TT	383	e2p_hash2string(sb->s_def_hash_version));
9522e0aa	384	if (!e2p_is_null_uuid(sb->s_hash_seed))
f61fc0b5 TT	385	fprintf(f, "Directory Hash Seed: %s\n",
f61fc0b5 TT	386	e2p_uuid2str(sb->s_hash_seed));
a435ec34 TT	387	if (sb->s_jnl_backup_type) {
	388	fprintf(f, "Journal backup: ");
	389	switch (sb->s_jnl_backup_type) {
	390	case 1:
	391	fprintf(f, "inode blocks\n");
	392	break;
	393	default:
	394	fprintf(f, "type %u\n", sb->s_jnl_backup_type);
	395	}
	396	}
65c6c3e0 TT	397	if (sb->s_backup_bgs[0] \|\| sb->s_backup_bgs[1]) {
	398	fprintf(f, "Backup block groups: ");
	399	if (sb->s_backup_bgs[0])
	400	fprintf(f, "%u ", sb->s_backup_bgs[0]);
	401	if (sb->s_backup_bgs[1])
	402	fprintf(f, "%u ", sb->s_backup_bgs[1]);
	403	fputc('\n', f);
	404	}
f5448c19 TT	405	if (sb->s_snapshot_inum) {
	406	fprintf(f, "Snapshot inode: %u\n",
	407	sb->s_snapshot_inum);
	408	fprintf(f, "Snapshot ID: %u\n",
	409	sb->s_snapshot_id);
	410	fprintf(f, "Snapshot reserved blocks: %llu\n",
	411	sb->s_snapshot_r_blocks_count);
	412	}
	413	if (sb->s_snapshot_list)
	414	fprintf(f, "Snapshot list head: %u\n",
	415	sb->s_snapshot_list);
993988f6 TT	416	if (sb->s_error_count)
	417	fprintf(f, "FS Error count: %u\n",
	418	sb->s_error_count);
	419	if (sb->s_first_error_time) {
	420	tm = sb->s_first_error_time;
	421	fprintf(f, "First error time: %s", ctime(&tm));
	422	memset(buf, 0, sizeof(buf));
cf5301d7	423	strncpy(buf, (char *)sb->s_first_error_func,
993988f6 TT	424	sizeof(sb->s_first_error_func));
	425	fprintf(f, "First error function: %s\n", buf);
	426	fprintf(f, "First error line #: %u\n",
	427	sb->s_first_error_line);
	428	fprintf(f, "First error inode #: %u\n",
	429	sb->s_first_error_ino);
	430	fprintf(f, "First error block #: %llu\n",
	431	sb->s_first_error_block);
	432	}
	433	if (sb->s_last_error_time) {
	434	tm = sb->s_last_error_time;
	435	fprintf(f, "Last error time: %s", ctime(&tm));
	436	memset(buf, 0, sizeof(buf));
cf5301d7	437	strncpy(buf, (char *)sb->s_last_error_func,
993988f6 TT	438	sizeof(sb->s_last_error_func));
	439	fprintf(f, "Last error function: %s\n", buf);
	440	fprintf(f, "Last error line #: %u\n",
	441	sb->s_last_error_line);
	442	fprintf(f, "Last error inode #: %u\n",
	443	sb->s_last_error_ino);
	444	fprintf(f, "Last error block #: %llu\n",
	445	sb->s_last_error_block);
	446	}
77b3e987	447	if (ext2fs_has_feature_mmp(sb)) {
0f5eba75 AD	448	fprintf(f, "MMP block number: %llu\n",
	449	(long long)sb->s_mmp_block);
	450	fprintf(f, "MMP update interval: %u\n",
	451	sb->s_mmp_update_interval);
	452	}
2d2d799c LX	453	for (qtype = 0; qtype < MAXQUOTAS; qtype++) {
	454	if (*quota_sb_inump(sb, qtype) != 0)
	455	fprintf(f, "%-26s%u\n",
	456	quota_type2prefix(qtype),
	457	*quota_sb_inump(sb, qtype));
	458	}
89efc88e	459
77b3e987	460	if (ext2fs_has_feature_metadata_csum(sb)) {
1eedf3e5 DW	461	fprintf(f, "Checksum type: %s\n",
1eedf3e5 DW	462	checksum_type(sb->s_checksum_type));
89efc88e TT	463	fprintf(f, "Checksum: 0x%08x\n",
89efc88e TT	464	sb->s_checksum);
1eedf3e5	465	}
41f22101 TT	466	if (!e2p_is_null_uuid(sb->s_encrypt_pw_salt))
	467	fprintf(f, "Encryption PW Salt: %s\n",
	468	e2p_uuid2str(sb->s_encrypt_pw_salt));
2ed0adbc DW	469
	470	if (ext2fs_has_feature_csum_seed(sb))
	471	fprintf(f, "Checksum seed: 0x%08x\n",
	472	sb->s_checksum_seed);
5a7761e8 TT	473	if (ext2fs_has_feature_fname_encoding(sb))
	474	fprintf(f, "Character encoding: %s\n",
	475	e2p_encoding2str(sb->s_encoding));
3839e657	476	}
1e3472c5	477
53d39550 TT	478	void list_super (struct ext2_super_block * s)
	479	{
	480	list_super2(s, stdout);
	481	}
1e3472c5	482