defs.set('LIBBLKID_DATE', libblkid_date)
defs.set('LIBBLKID_VERSION', pc_version)
-blkid_h = configure_file(
+configure_file(
input : 'src/blkid.h.in',
output : 'blkid.h',
configuration : defs,
/* set PTUUID variable for non-binary API for tables where
* the ID is just a string */
-int blkid_partitions_strcpy_ptuuid(blkid_probe pr, char *str)
+int blkid_partitions_strcpy_ptuuid(blkid_probe pr, const char *str)
{
struct blkid_chain *chn = blkid_probe_get_chain(pr);
extern int blkid_partitions_need_typeonly(blkid_probe pr);
extern int blkid_partitions_set_ptuuid(blkid_probe pr, unsigned char *uuid);
-extern int blkid_partitions_strcpy_ptuuid(blkid_probe pr, char *str);
+extern int blkid_partitions_strcpy_ptuuid(blkid_probe pr, const char *str);
extern int blkid_is_nested_dimension(blkid_partition par,
blkid_probe_set_fsblocksize(pr, block_size);
blkid_probe_set_block_size(pr, block_size);
+ blkid_probe_set_fsendianness(pr,
+ fs_le ? BLKID_ENDIANNESS_LITTLE : BLKID_ENDIANNESS_BIG);
return BLKID_PROBE_OK;
}
blkid_probe_set_label(pr, cs->name, sizeof(cs->name));
blkid_probe_set_fssize(pr, cfs32_to_cpu(le, cs->size));
blkid_probe_sprintf_version(pr, "%d", v2 ? 2 : 1);
+ blkid_probe_set_fsendianness(pr,
+ le ? BLKID_ENDIANNESS_LITTLE : BLKID_ENDIANNESS_BIG);
return 0;
}
#include <time.h>
#include "superblocks.h"
+#include "crc32c.h"
struct ext2_super_block {
uint32_t s_inodes_count;
uint16_t s_mmp_interval;
uint64_t s_mmp_block;
uint32_t s_raid_stripe_width;
- uint32_t s_reserved[163];
+ uint32_t s_reserved[162];
+ uint32_t s_checksum;
} __attribute__((packed));
/* magic string */
#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020
#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040
+#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400
/* for s_feature_incompat */
#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002
struct ext2_super_block *es;
es = (struct ext2_super_block *)
- blkid_probe_get_buffer(pr, EXT_SB_OFF, 0x200);
+ blkid_probe_get_buffer(pr, EXT_SB_OFF, sizeof(struct ext2_super_block));
if (!es)
return NULL;
+ if (le32_to_cpu(es->s_feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
+ uint32_t csum = crc32c(~0, es, offsetof(struct ext2_super_block, s_checksum));
+ if (!blkid_probe_verify_csum(pr, csum, le32_to_cpu(es->s_checksum)))
+ return NULL;
+ }
if (fc)
*fc = le32_to_cpu(es->s_feature_compat);
if (fi)
js = blkid_probe_get_sb(pr, mag, struct jfs_super_block);
if (!js)
return errno ? -errno : 1;
+ if (le16_to_cpu(js->js_l2bsize) > 32 || le16_to_cpu(js->js_l2pbsize) > 32)
+ return 1;
if (le32_to_cpu(js->js_bsize) != (1U << le16_to_cpu(js->js_l2bsize)))
return 1;
if (le32_to_cpu(js->js_pbsize) != (1U << le16_to_cpu(js->js_l2pbsize)))
blkid_probe_sprintf_version(pr, "%d", version);
blkid_probe_set_fsblocksize(pr, block_size);
blkid_probe_set_block_size(pr, block_size);
+ blkid_probe_set_fsendianness(pr, !swabme ?
+ BLKID_ENDIANNESS_NATIVE : BLKID_ENDIANNESS_OTHER);
return 0;
}
struct romfs_super_block {
unsigned char ros_magic[8];
- uint32_t ros_dummy1[2];
+ uint32_t ros_full_size;
+ uint32_t ros_checksum;
unsigned char ros_volume[16];
} __attribute__((packed));
+static int romfs_verify_csum(blkid_probe pr, const struct blkid_idmag *mag,
+ const struct romfs_super_block *ros)
+{
+ uint32_t csummed_size = min((uint32_t) 512,
+ be32_to_cpu(ros->ros_full_size));
+ unsigned char *csummed;
+ uint32_t csum;
+
+ if (csummed_size % sizeof(uint32_t) != 0)
+ return 0;
+
+ csummed = blkid_probe_get_sb_buffer(pr, mag, csummed_size);
+ if (!csummed)
+ return 0;
+
+ csum = 0;
+ while (csummed_size) {
+ csum += be32_to_cpu(*(uint32_t *) csummed);
+ csummed_size -= sizeof(uint32_t);
+ csummed += sizeof(uint32_t);
+ }
+ return blkid_probe_verify_csum(pr, csum, 0);
+}
+
static int probe_romfs(blkid_probe pr, const struct blkid_idmag *mag)
{
struct romfs_super_block *ros;
if (!ros)
return errno ? -errno : 1;
+ if (!romfs_verify_csum(pr, mag, ros))
+ return 1;
+
if (*((char *) ros->ros_volume) != '\0')
blkid_probe_set_label(pr, ros->ros_volume,
sizeof(ros->ros_volume));
blkid_probe_set_fsblocksize(pr, 1024);
+ blkid_probe_set_fssize(pr, be32_to_cpu(ros->ros_full_size));
blkid_probe_set_block_size(pr, 1024);
return 0;
struct sqsh_super_block *sq;
uint16_t vermaj;
uint16_t vermin;
+ enum BLKID_ENDIANNESS endianness;
sq = blkid_probe_get_sb(pr, mag, struct sqsh_super_block);
if (!sq)
if (strcmp(mag->magic, "sqsh") == 0) {
vermaj = be16_to_cpu(sq->s_major);
vermin = be16_to_cpu(sq->s_minor);
+ endianness = BLKID_ENDIANNESS_BIG;
} else {
vermaj = le16_to_cpu(sq->s_major);
vermin = le16_to_cpu(sq->s_minor);
+ endianness = BLKID_ENDIANNESS_LITTLE;
}
if (vermaj > 3)
blkid_probe_set_fsblocksize(pr, 1024);
blkid_probe_set_block_size(pr, 1024);
+ blkid_probe_set_fsendianness(pr, endianness);
return 0;
}
int blkid_probe_set_block_size(blkid_probe pr, unsigned block_size)
{
- struct blkid_chain *chn = blkid_probe_get_chain(pr);
-
- if (!(chn->flags & BLKID_SUBLKS_FSINFO))
- return 0;
-
return blkid_probe_sprintf_value(pr, "BLOCK_SIZE", "%u", block_size);
}
static int blkid_probe_set_usage(blkid_probe pr, int usage)
{
struct blkid_chain *chn = blkid_probe_get_chain(pr);
- char *u = NULL;
+ const char *u = NULL;
if (!(chn->flags & BLKID_SUBLKS_USAGE))
return 0;
else
u = "unknown";
- return blkid_probe_set_value(pr, "USAGE", (unsigned char *) u, strlen(u) + 1);
+ return blkid_probe_set_value(pr, "USAGE",
+ (const unsigned char *) u, strlen(u) + 1);
}
int blkid_probe_set_fssize(blkid_probe pr, uint64_t size)
block_size);
}
+int blkid_probe_set_fsendianness(blkid_probe pr, enum BLKID_ENDIANNESS endianness)
+{
+ struct blkid_chain *chn = blkid_probe_get_chain(pr);
+ const char *value;
+
+ if (!(chn->flags & BLKID_SUBLKS_FSINFO))
+ return 0;
+
+ switch (endianness) {
+ case BLKID_ENDIANNESS_LITTLE:
+ value = "LITTLE";
+ break;
+ case BLKID_ENDIANNESS_BIG:
+ value = "BIG";
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return blkid_probe_set_value(pr, "ENDIANNESS",
+ (const unsigned char *) value, strlen(value) + 1);
+
+}
+
int blkid_probe_set_id_label(blkid_probe pr, const char *name,
const unsigned char *data, size_t len)
{
#include "blkidP.h"
+enum BLKID_ENDIANNESS {
+ BLKID_ENDIANNESS_LITTLE,
+ BLKID_ENDIANNESS_BIG,
+};
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define BLKID_ENDIANNESS_NATIVE BLKID_ENDIANNESS_LITTLE
+#define BLKID_ENDIANNESS_OTHER BLKID_ENDIANNESS_BIG
+#else
+#define BLKID_ENDIANNESS_NATIVE BLKID_ENDIANNESS_BIG
+#define BLKID_ENDIANNESS_OTHER BLKID_ENDIANNESS_LITTLE
+#endif
+
extern const struct blkid_idinfo cramfs_idinfo;
extern const struct blkid_idinfo swap_idinfo;
extern const struct blkid_idinfo swsuspend_idinfo;
int blkid_probe_set_fssize(blkid_probe pr, uint64_t size);
int blkid_probe_set_fslastblock(blkid_probe pr, uint64_t lastblock);
int blkid_probe_set_fsblocksize(blkid_probe pr, uint32_t block_size);
+int blkid_probe_set_fsendianness(blkid_probe pr, enum BLKID_ENDIANNESS endianness);
extern int blkid_probe_is_bitlocker(blkid_probe pr);
extern int blkid_probe_is_ntfs(blkid_probe pr);
blkid_probe_set_fsblocksize(pr, bsize);
blkid_probe_set_block_size(pr, bsize);
+ blkid_probe_set_fsendianness(pr, is_be ?
+ BLKID_ENDIANNESS_BIG : BLKID_ENDIANNESS_LITTLE);
return 0;
}
(unsigned char *) &ub->ub_magic))
return 1;
+ blkid_probe_set_fsendianness(pr, !swab_endian ?
+ BLKID_ENDIANNESS_NATIVE : BLKID_ENDIANNESS_OTHER);
+
return 0;
}
defs.set('LIBFDISK_MINOR_VERSION', pc_version.split('.')[1])
defs.set('LIBFDISK_PATCH_VERSION', pc_version.split('.')[2])
-libfdisk_h = configure_file(
+configure_file(
input : 'src/libfdisk.h.in',
output : 'libfdisk.h',
configuration : defs,
defs.set('LIBMOUNT_MINOR_VERSION', pc_version.split('.')[1])
defs.set('LIBMOUNT_PATCH_VERSION', pc_version.split('.')[2])
-libmount_h = configure_file(
+configure_file(
input : 'src/libmount.h.in',
output : 'libmount.h',
configuration : defs,
defs = configuration_data()
defs.set('LIBSMARTCOLS_VERSION', pc_version)
-libsmartcols_h = configure_file(
+configure_file(
input : 'src/libsmartcols.h.in',
output : 'libsmartcols.h',
configuration : defs,
n++;
sum += ce->width + extra;
}
- st->width_avg = sum / n;
+
+ if (n)
+ st->width_avg = sum / n;
/* count deviation */
if (n > 1) {
execprefixdir = prefixdir
usrbin_exec_dir = join_paths(execprefixdir, bindir)
usrsbin_exec_dir = join_paths(execprefixdir, sbindir)
-sysconfdir = '/etc'
-localstatedir = '/var'
bash_completion = dependency('bash-completion', required : get_option('build-bash-completion'))
vendordir = get_option('vendordir')
'tinfo',
required : get_option('tinfo'))
-lib_tinfo_static = dependency(
- 'tinfo',
- static : true,
- required : need_static_libs ? get_option('tinfo') : disabler())
-
lib_ncursesw = dependency(
'ncursesw',
required : get_option('ncursesw'))
have = cc.has_function('timer_create')
if not have
- realtime_libs = cc.find_library('rt', required : true)
+ realtime_libs = [cc.find_library('rt', required : true)]
have = cc.has_function('timer_create',
dependencies : realtime_libs)
if not have
meson_make_symlink = meson.current_source_dir() + '/tools/meson-make-symlink.sh'
meson_make_manpage_stub = meson.current_source_dir() + '/tools/meson-make-manpage-stub.sh'
-config_h = configure_file(
+configure_file(
output : 'config.h',
configuration : conf)
exes += exe
endif
+exe = executable(
+ 'fadvise',
+ fadvise_sources,
+ include_directories : includes,
+ link_with : [lib_common],
+ install_dir : usrbin_exec_dir,
+ install : true)
+if not is_disabler(exe)
+ exes += exe
+ manadocs += ['misc-utils/fadvise.1.adoc']
+ bashcompletions += ['fadvise']
+endif
+
############################################################
opt = not get_option('build-schedutils').disabled()
Do not restrict the command-name-to-PID conversion to processes with the same UID as the present process.
*-p*, *--pid*::
Only print the process ID (PID) of the named processes, do not send any signals.
+*-r*, *--require-handler*::
+Do not send the signal if it is not caught in userspace by the signalled process.
*--verbose*::
Print PID(s) that will be signaled with *kill* along with the signal.
*-q*, *--queue* _value_::
check_all:1,
do_kill:1,
do_pid:1,
+ require_handler:1,
use_sigval:1,
#ifdef UL_HAVE_PIDFD
timeout:1,
fputs(_(" -p, --pid print pids without signaling them\n"), out);
fputs(_(" -l, --list[=<signal>] list signal names, or convert a signal number to a name\n"), out);
fputs(_(" -L, --table list signal names and numbers\n"), out);
+ fputs(_(" -r, --require-handler do not send signal if signal handler is not present\n"), out);
fputs(_(" --verbose print pids that will be signaled\n"), out);
fputs(USAGE_SEPARATOR, out);
print_all_signals(stdout, 1);
exit(EXIT_SUCCESS);
}
+ if (!strcmp(arg, "-r") || !strcmp(arg, "--require-handler")) {
+ ctl->require_handler = 1;
+ continue;
+ }
if (!strcmp(arg, "-p") || !strcmp(arg, "--pid")) {
ctl->do_pid = 1;
if (ctl->do_kill)
return rc;
}
+static int check_signal_handler(const struct kill_control *ctl)
+{
+ uintmax_t sigcgt = 0;
+ int rc = 0, has_hnd = 0;
+ struct path_cxt *pc;
+
+ if (!ctl->require_handler)
+ return 1;
+
+ pc = ul_new_procfs_path(ctl->pid, NULL);
+ if (!pc)
+ return -ENOMEM;
+
+ rc = procfs_process_get_stat_nth(pc, 34, &sigcgt);
+ if (rc)
+ return -EINVAL;
+
+ ul_unref_path(pc);
+
+ has_hnd = ((1UL << (ctl->numsig - 1)) & sigcgt) != 0;
+ if (ctl->verbose && !has_hnd)
+ printf(_("not signalling pid %d, it has no userspace handler for signal %d\n"), ctl->pid, ctl->numsig);
+
+ return has_hnd;
+}
+
int main(int argc, char **argv)
{
struct kill_control ctl = { .numsig = SIGTERM };
errno = 0;
ctl.pid = strtol(ctl.arg, &ep, 10);
if (errno == 0 && ep && *ep == '\0' && ctl.arg < ep) {
+ if (check_signal_handler(&ctl) <= 0)
+ continue;
if (kill_verbose(&ctl) != 0)
nerrs++;
ct++;
continue;
if (procfs_dirent_get_pid(d, &ctl.pid) != 0)
continue;
+ if (check_signal_handler(&ctl) <= 0)
+ continue;
if (kill_verbose(&ctl) != 0)
nerrs++;
ctl->tag = ctl->login = xgetlogin();
if (!ctl->tag)
ctl->tag = "<someone>";
-
- generate_syslog_header(ctl);
}
/* re-open; usually after failed connection */
{
/* note: we re-generate the syslog header for each log message to
* update header timestamps and to reflect possible priority changes.
- * The initial header is generated by logger_open().
*/
int default_priority = ctl->pri;
- int last_pri = default_priority;
char *buf = xmalloc(ctl->max_message_size + 2 + 2);
int pri;
int c;
} else
ctl->pri = default_priority;
- if (ctl->pri != last_pri) {
- generate_syslog_header(ctl);
- last_pri = ctl->pri;
- }
if (c != EOF && c != '\n')
c = getchar();
}
}
buf[i] = '\0';
- if (i > 0 || !ctl->skip_empty_lines)
+ if (i > 0 || !ctl->skip_empty_lines) {
+ generate_syslog_header(ctl);
write_output(ctl, buf);
+ }
if (c == '\n') /* discard line terminator */
c = getchar();
abort();
}
logger_open(&ctl);
- if (0 < argc)
+ if (0 < argc) {
+ generate_syslog_header(&ctl);
logger_command_line(&ctl, argv);
- else
+ } else
/* Note. --file <arg> reopens stdin making the below
* function to be used for file inputs. */
logger_stdin(&ctl);
+
logger_close(&ctl);
return EXIT_SUCCESS;
}
.free = NULL,
};
+static bool L3_verify_initial_line(const char *line)
+{
+ /* At least we expect two white spaces. */
+ if (strncmp (line, " ", 2) != 0)
+ return false;
+ line += 2;
+
+ /* Skip white spaces. */
+ while (*line == ' ')
+ line++;
+
+ return (strncmp(line, "sl", 2) == 0);
+}
+
#define TCP_LINE_LEN 256
static void load_xinfo_from_proc_inet_L3(ino_t netns_inode, const char *proc_file,
- bool (*verify_initial_line)(const char *),
struct sock_xinfo_class *class)
{
char line[TCP_LINE_LEN];
if (fgets(line, sizeof(line), tcp_fp) == NULL)
goto out;
- if (!verify_initial_line(line))
+ if (!L3_verify_initial_line(line))
/* Unexpected line */
goto out;
fclose(tcp_fp);
}
-static bool tcp_verify_initial_line(const char *line)
-{
- return (line[0] == ' ' && line[1] == ' '
- && line[2] == 's' && line[3] == 'l');
-}
-
static void load_xinfo_from_proc_tcp(ino_t netns_inode)
{
load_xinfo_from_proc_inet_L3(netns_inode,
- "/proc/net/tcp", tcp_verify_initial_line,
+ "/proc/net/tcp",
&tcp_xinfo_class);
}
.free = NULL,
};
-static bool udp_verify_initial_line(const char *line)
-{
- return (line[0] == ' ' && line[1] == ' ' && line[2] == ' '
- && line[3] == 's' && line[4] == 'l');
-}
-
-
static void load_xinfo_from_proc_udp(ino_t netns_inode)
{
load_xinfo_from_proc_inet_L3(netns_inode,
"/proc/net/udp",
- udp_verify_initial_line,
&udp_xinfo_class);
}
char field[256];
size_t i = 0;
struct libscols_table *tb;
- struct libscols_line *sec = NULL;
+ struct libscols_line *sec;
int hdr_caches = 0;
scols_init_debug(0);
ct = lscpu_cputype_get_default(cxt);
/* Section: architecture */
- if (cxt->arch)
- sec = add_summary_s(tb, NULL, _("Architecture:"), cxt->arch->name);
- if (cxt->arch && (cxt->arch->bit32 || cxt->arch->bit64)) {
+ sec = add_summary_s(tb, NULL, _("Architecture:"), cxt->arch->name);
+ if (cxt->arch->bit32 || cxt->arch->bit64) {
char buf[32], *p = buf;
if (cxt->arch->bit32) {
if (username) {
if (options.autolog)
login_argv[login_argc++] = "-f";
- else
- login_argv[login_argc++] = "--";
+ login_argv[login_argc++] = "--";
login_argv[login_argc++] = username;
}
}
ID_FS_BLOCK_SIZE=1024
+ID_FS_ENDIANNESS=LITTLE
ID_FS_FSBLOCKSIZE=1024
ID_FS_LABEL=befs_test
ID_FS_LABEL_ENC=befs_test
+ID_FS_ENDIANNESS=LITTLE
ID_FS_FSSIZE=4096
ID_FS_LABEL=test-cram
ID_FS_LABEL_ENC=test-cram
+ID_FS_ENDIANNESS=BIG
ID_FS_FSSIZE=4096
ID_FS_LABEL=Compressed
ID_FS_LABEL_ENC=Compressed
--- /dev/null
+ID_FS_BLOCK_SIZE=1024
+ID_FS_FSBLOCKSIZE=1024
+ID_FS_FSLASTBLOCK=65536
+ID_FS_FSSIZE=67108864
+ID_FS_LABEL=test-ext4
+ID_FS_LABEL_ENC=test-ext4
+ID_FS_TYPE=ext4
+ID_FS_USAGE=filesystem
+ID_FS_UUID=ada110f6-bd6d-49db-955d-342c27627b61
+ID_FS_UUID_ENC=ada110f6-bd6d-49db-955d-342c27627b61
+ID_FS_VERSION=1.0
ID_FS_BLOCK_SIZE=1024
+ID_FS_ENDIANNESS=BIG
ID_FS_FSBLOCKSIZE=1024
ID_FS_TYPE=minix
ID_FS_USAGE=filesystem
ID_FS_BLOCK_SIZE=1024
+ID_FS_ENDIANNESS=LITTLE
ID_FS_FSBLOCKSIZE=1024
ID_FS_TYPE=minix
ID_FS_USAGE=filesystem
ID_FS_BLOCK_SIZE=1024
ID_FS_FSBLOCKSIZE=1024
+ID_FS_FSSIZE=96
ID_FS_LABEL=test-romfs
ID_FS_LABEL_ENC=test-romfs
ID_FS_TYPE=romfs
--- /dev/null
+ID_FS_BLOCK_SIZE=1024
+ID_FS_ENDIANNESS=LITTLE
+ID_FS_FSBLOCKSIZE=1024
+ID_FS_TYPE=squashfs3
+ID_FS_USAGE=filesystem
+ID_FS_VERSION=3.1
--- /dev/null
+ID_FS_TYPE=squashfs
+ID_FS_USAGE=filesystem
+ID_FS_VERSION=4.0
ID_FS_BLOCK_SIZE=2048
+ID_FS_ENDIANNESS=LITTLE
ID_FS_FSBLOCKSIZE=2048
ID_FS_TYPE=ufs
ID_FS_USAGE=filesystem
ID_FS_BLOCK_SIZE=512
+ID_FS_ENDIANNESS=LITTLE
ID_FS_FSBLOCKSIZE=512
ID_FS_LABEL=tank
ID_FS_LABEL_ENC=tank
projects / thirdparty / util-linux.git / commitdiff
