picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

use memzero(foo, length); for all memset(foo, 0, length); calls

Browse source 
In trying to track down a stupid linker bug, I noticed a bunch of
memset() calls that should be using memzero() to make it more "obvious"
that the options are correct (i.e. 0 is not the length, but the data to
set).  So fix up all current calls to memset(foo, 0, length) to
memzero(foo, length).
This commit is contained in:
Greg KH 2014-01-31 06:51:32 +01:00 committed by Tom Gundersen
parent b5cfa7408c
commit 29804cc1e0
24 changed files with 60 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/boot/boot-efi.c
View file

@ -69,7 +69,7 @@ static int get_boot_entries(struct boot_info *info) {
info->fw_entries = e; info->fw_entries = e;
e = &info->fw_entries[info->fw_entries_count]; e = &info->fw_entries[info->fw_entries_count];
memset(e, 0, sizeof(struct boot_info_entry)); memzero(e, sizeof(struct boot_info_entry));
e->order = -1; e->order = -1;
err = efi_get_boot_option(list[i], &e->title, &e->part_uuid, &e->path); err = efi_get_boot_option(list[i], &e->title, &e->part_uuid, &e->path);

2
src/bootchart/svg.c
View file

@ -1248,7 +1248,7 @@ static void svg_top_ten_pss(void) {
void svg_do(const char *build) { void svg_do(const char *build) {
struct ps_struct *ps; struct ps_struct *ps;
memset(&str, 0, sizeof(str)); memzero(&str, sizeof(str));
ps = ps_first; ps = ps_first;

2
src/bus-proxyd/bus-proxyd.c
View file

@ -172,7 +172,7 @@ static int rename_service(sd_bus *a, sd_bus *b) {
uid, name); uid, name);
if (m > w) if (m > w)
memset(arg_command_line_buffer + w, 0, m - w); memzero(arg_command_line_buffer + w, m - w);
} }
log_debug("Running on behalf of PID "PID_FMT" (%s), UID "UID_FMT" (%s), %s", log_debug("Running on behalf of PID "PID_FMT" (%s), UID "UID_FMT" (%s), %s",

4
src/journal/fsprg.c
View file

@ -51,7 +51,7 @@ static void mpi_export(void *buf, size_t buflen, const gcry_mpi_t x) {
assert(gcry_mpi_cmp_ui(x, 0) >= 0); assert(gcry_mpi_cmp_ui(x, 0) >= 0);
len = (gcry_mpi_get_nbits(x) + 7) / 8; len = (gcry_mpi_get_nbits(x) + 7) / 8;
assert(len <= buflen); assert(len <= buflen);
memset(buf, 0, buflen); memzero(buf, buflen);
gcry_mpi_print(GCRYMPI_FMT_USG, buf + (buflen - len), len, &nwritten, x); gcry_mpi_print(GCRYMPI_FMT_USG, buf + (buflen - len), len, &nwritten, x);
assert(nwritten == len); assert(nwritten == len);
} }
@ -306,7 +306,7 @@ void FSPRG_GenState0(void *state, const void *mpk, const void *seed, size_t seed
memcpy(state, mpk, 2 + secpar / 8); memcpy(state, mpk, 2 + secpar / 8);
mpi_export(state + 2 + 1 * secpar / 8, secpar / 8, x); mpi_export(state + 2 + 1 * secpar / 8, secpar / 8, x);
memset(state + 2 + 2 * secpar / 8, 0, 8); memzero(state + 2 + 2 * secpar / 8, 8);
gcry_mpi_release(n); gcry_mpi_release(n);
gcry_mpi_release(x); gcry_mpi_release(x);

4
src/journal/journal-file.c
View file

@ -560,7 +560,7 @@ static int journal_file_setup_data_hash_table(JournalFile *f) {
if (r < 0) if (r < 0)
return r; return r;
memset(o->hash_table.items, 0, s); memzero(o->hash_table.items, s);
f->header->data_hash_table_offset = htole64(p + offsetof(Object, hash_table.items)); f->header->data_hash_table_offset = htole64(p + offsetof(Object, hash_table.items));
f->header->data_hash_table_size = htole64(s); f->header->data_hash_table_size = htole64(s);
@ -586,7 +586,7 @@ static int journal_file_setup_field_hash_table(JournalFile *f) {
if (r < 0) if (r < 0)
return r; return r;
memset(o->hash_table.items, 0, s); memzero(o->hash_table.items, s);
f->header->field_hash_table_offset = htole64(p + offsetof(Object, hash_table.items)); f->header->field_hash_table_offset = htole64(p + offsetof(Object, hash_table.items));
f->header->field_hash_table_size = htole64(s); f->header->field_hash_table_size = htole64(s);

7
src/libsystemd-daemon/sd-daemon.c
View file

@ -47,6 +47,7 @@
# include <mqueue.h> # include <mqueue.h>
#endif #endif
#include "util.h"
#include "sd-daemon.h" #include "sd-daemon.h"
#if (__GNUC__ >= 4) #if (__GNUC__ >= 4)
@ -441,18 +442,18 @@ _sd_export_ int sd_notify(int unset_environment, const char *state) {
goto finish; goto finish;
} }
memset(&sockaddr, 0, sizeof(sockaddr)); memzero(&sockaddr, sizeof(sockaddr));
sockaddr.sa.sa_family = AF_UNIX; sockaddr.sa.sa_family = AF_UNIX;
strncpy(sockaddr.un.sun_path, e, sizeof(sockaddr.un.sun_path)); strncpy(sockaddr.un.sun_path, e, sizeof(sockaddr.un.sun_path));
if (sockaddr.un.sun_path[0] == '@') if (sockaddr.un.sun_path[0] == '@')
sockaddr.un.sun_path[0] = 0; sockaddr.un.sun_path[0] = 0;
memset(&iovec, 0, sizeof(iovec)); memzero(&iovec, sizeof(iovec));
iovec.iov_base = (char*) state; iovec.iov_base = (char*) state;
iovec.iov_len = strlen(state); iovec.iov_len = strlen(state);
memset(&msghdr, 0, sizeof(msghdr)); memzero(&msghdr, sizeof(msghdr));
msghdr.msg_name = &sockaddr; msghdr.msg_name = &sockaddr;
msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(e); msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(e);

4
src/libsystemd/sd-bus/bus-kernel.c
View file

@ -140,7 +140,7 @@ static int bus_message_setup_bloom(sd_bus_message *m, struct kdbus_bloom_filter
assert(bloom); assert(bloom);
data = bloom->data; data = bloom->data;
memset(data, 0, m->bus->bloom_size); memzero(data, m->bus->bloom_size);
bloom->generation = 0; bloom->generation = 0;
bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type)); bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
@ -256,7 +256,7 @@ static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
} }
m->free_kdbus = true; m->free_kdbus = true;
memset(m->kdbus, 0, sz); memzero(m->kdbus, sz);
m->kdbus->flags = m->kdbus->flags =
((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) | ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |

12
src/libsystemd/sd-bus/bus-message.c
View file

@ -194,7 +194,7 @@ static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz, b
/* Zero out padding */ /* Zero out padding */
if (start > old_size) if (start > old_size)
memset((uint8_t*) np + old_size, 0, start - old_size); memzero((uint8_t*) np + old_size, start - old_size);
op = m->header; op = m->header;
m->header = np; m->header = np;
@ -252,7 +252,7 @@ static int message_append_field_string(
return -ENOMEM; return -ENOMEM;
p[0] = h; p[0] = h;
memset(p+1, 0, 7); memzero(p+1, 7);
memcpy(p+8, s, l); memcpy(p+8, s, l);
p[8+l] = 0; p[8+l] = 0;
p[8+l+1] = 0; p[8+l+1] = 0;
@ -337,7 +337,7 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x)
return -ENOMEM; return -ENOMEM;
p[0] = h; p[0] = h;
memset(p+1, 0, 7); memzero(p+1, 7);
*((uint32_t*) (p + 8)) = x; *((uint32_t*) (p + 8)) = x;
p[12] = 0; p[12] = 0;
p[13] = 'u'; p[13] = 'u';
@ -1228,7 +1228,7 @@ static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz, boo
return NULL; return NULL;
if (padding > 0) { if (padding > 0) {
memset(p, 0, padding); memzero(p, padding);
p = (uint8_t*) p + padding; p = (uint8_t*) p + padding;
} }
@ -2514,7 +2514,7 @@ _public_ int sd_bus_message_append_array_iovec(
if (iov[i].iov_base) if (iov[i].iov_base)
memcpy(p, iov[i].iov_base, iov[i].iov_len); memcpy(p, iov[i].iov_base, iov[i].iov_len);
else else
memset(p, 0, iov[i].iov_len); memzero(p, iov[i].iov_len);
p = (uint8_t*) p + iov[i].iov_len; p = (uint8_t*) p + iov[i].iov_len;
} }
@ -2779,7 +2779,7 @@ int bus_message_seal(sd_bus_message *m, uint64_t cookie, usec_t timeout) {
l = BUS_MESSAGE_FIELDS_SIZE(m); l = BUS_MESSAGE_FIELDS_SIZE(m);
a = ALIGN8(l) - l; a = ALIGN8(l) - l;
if (a > 0) if (a > 0)
memset((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, 0, a); memzero((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, a);
/* If this is something we can send as memfd, then let's seal /* If this is something we can send as memfd, then let's seal
the memfd now. Note that we can send memfds as payload only the memfd now. Note that we can send memfds as payload only

2
src/libudev/libudev-device.c
View file

@ -810,7 +810,7 @@ _public_ struct udev_device *udev_device_new_from_device_id(struct udev *udev, c
sk = socket(PF_INET, SOCK_DGRAM, 0); sk = socket(PF_INET, SOCK_DGRAM, 0);
if (sk < 0) if (sk < 0)
return NULL; return NULL;
memset(&ifr, 0x00, sizeof(struct ifreq)); memzero(&ifr, sizeof(struct ifreq));
ifr.ifr_ifindex = ifindex; ifr.ifr_ifindex = ifindex;
if (ioctl(sk, SIOCGIFNAME, &ifr) != 0) { if (ioctl(sk, SIOCGIFNAME, &ifr) != 0) {
close(sk); close(sk);

2
src/libudev/libudev-list.c
View file

@ -95,7 +95,7 @@ static inline struct udev_list_entry *list_node_to_entry(struct udev_list_node *
void udev_list_init(struct udev *udev, struct udev_list *list, bool unique) void udev_list_init(struct udev *udev, struct udev_list *list, bool unique)
{ {
memset(list, 0x00, sizeof(struct udev_list)); memzero(list, sizeof(struct udev_list));
list->udev = udev; list->udev = udev;
list->unique = unique; list->unique = unique;
udev_list_node_init(&list->node); udev_list_node_init(&list->node);

10
src/libudev/libudev-monitor.c
View file

@ -291,7 +291,7 @@ _public_ int udev_monitor_filter_update(struct udev_monitor *udev_monitor)
udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL) udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL)
return 0; return 0;
memset(ins, 0x00, sizeof(ins)); memzero(ins, sizeof(ins));
i = 0; i = 0;
/* load magic in A */ /* load magic in A */
@ -371,7 +371,7 @@ _public_ int udev_monitor_filter_update(struct udev_monitor *udev_monitor)
bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff); bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
/* install filter */ /* install filter */
memset(&filter, 0x00, sizeof(filter)); memzero(&filter, sizeof(filter));
filter.len = i; filter.len = i;
filter.filter = ins; filter.filter = ins;
err = setsockopt(udev_monitor->sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)); err = setsockopt(udev_monitor->sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
@ -599,7 +599,7 @@ retry:
return NULL; return NULL;
iov.iov_base = &buf; iov.iov_base = &buf;
iov.iov_len = sizeof(buf); iov.iov_len = sizeof(buf);
memset (&smsg, 0x00, sizeof(struct msghdr)); memzero(&smsg, sizeof(struct msghdr));
smsg.msg_iov = &iov; smsg.msg_iov = &iov;
smsg.msg_iovlen = 1; smsg.msg_iovlen = 1;
smsg.msg_control = cred_msg; smsg.msg_control = cred_msg;
@ -744,7 +744,7 @@ int udev_monitor_send_device(struct udev_monitor *udev_monitor,
return -EINVAL; return -EINVAL;
/* add versioned header */ /* add versioned header */
memset(&nlh, 0x00, sizeof(struct udev_monitor_netlink_header)); memzero(&nlh, sizeof(struct udev_monitor_netlink_header));
memcpy(nlh.prefix, "libudev", 8); memcpy(nlh.prefix, "libudev", 8);
nlh.magic = htonl(UDEV_MONITOR_MAGIC); nlh.magic = htonl(UDEV_MONITOR_MAGIC);
nlh.header_size = sizeof(struct udev_monitor_netlink_header); nlh.header_size = sizeof(struct udev_monitor_netlink_header);
@ -771,7 +771,7 @@ int udev_monitor_send_device(struct udev_monitor *udev_monitor,
iov[1].iov_base = (char *)buf; iov[1].iov_base = (char *)buf;
iov[1].iov_len = blen; iov[1].iov_len = blen;
memset(&smsg, 0x00, sizeof(struct msghdr)); memzero(&smsg, sizeof(struct msghdr));
smsg.msg_iov = iov; smsg.msg_iov = iov;
smsg.msg_iovlen = 2; smsg.msg_iovlen = 2;
/* /*

3
src/python-systemd/_journal.c
View file

@ -22,6 +22,7 @@
#include <Python.h> #include <Python.h>
#include <alloca.h> #include <alloca.h>
#include "util.h"
#define SD_JOURNAL_SUPPRESS_LOCATION #define SD_JOURNAL_SUPPRESS_LOCATION
#include <systemd/sd-journal.h> #include <systemd/sd-journal.h>
@ -41,7 +42,7 @@ static PyObject *journal_sendv(PyObject *self, PyObject *args) {
/* Allocate an array for the argument strings */ /* Allocate an array for the argument strings */
argc = PyTuple_Size(args); argc = PyTuple_Size(args);
encoded = alloca(argc * sizeof(PyObject*)); encoded = alloca(argc * sizeof(PyObject*));
memset(encoded, 0, argc * sizeof(PyObject*)); memzero(encoded, argc * sizeof(PyObject*));
/* Allocate sufficient iovector space for the arguments. */ /* Allocate sufficient iovector space for the arguments. */
iov = alloca(argc * sizeof(struct iovec)); iov = alloca(argc * sizeof(struct iovec));

2
src/readahead/readahead-collect.c
View file

@ -130,7 +130,7 @@ static int pack_file(FILE *pack, const char *fn, bool on_btrfs) {
pages = l / page_size(); pages = l / page_size();
vec = alloca(pages); vec = alloca(pages);
memset(vec, 0, pages); memzero(vec, pages);
if (mincore(start, l, vec) < 0) { if (mincore(start, l, vec) < 0) {
log_warning("mincore(%s) failed: %m", fn); log_warning("mincore(%s) failed: %m", fn);
r = -errno; r = -errno;

2
src/shared/hashmap.c
View file

@ -201,7 +201,7 @@ Hashmap *hashmap_new(hash_func_t hash_func, compare_func_t compare_func) {
if (!h) if (!h)
return NULL; return NULL;
memset(h, 0, size); memzero(h, size);
} else { } else {
h = malloc0(size); h = malloc0(size);

4
src/shared/util.c
View file

@ -2337,7 +2337,7 @@ void rename_process(const char name[8]) {
if (!saved_argv[i]) if (!saved_argv[i])
break; break;
memset(saved_argv[i], 0, strlen(saved_argv[i])); memzero(saved_argv[i], strlen(saved_argv[i]));
} }
} }
} }
@ -5792,7 +5792,7 @@ void* greedy_realloc0(void **p, size_t *allocated, size_t need) {
return NULL; return NULL;
if (*allocated > prev) if (*allocated > prev)
memset(&q[prev], 0, *allocated - prev); memzero(&q[prev], *allocated - prev);
return q; return q;
} }

4
src/test/test-libudev.c
View file

@ -253,7 +253,7 @@ static int test_monitor(struct udev *udev) {
goto out; goto out;
} }
memset(&ep_udev, 0, sizeof(struct epoll_event)); memzero(&ep_udev, sizeof(struct epoll_event));
ep_udev.events = EPOLLIN; ep_udev.events = EPOLLIN;
ep_udev.data.fd = fd_udev; ep_udev.data.fd = fd_udev;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) { if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) {
@ -261,7 +261,7 @@ static int test_monitor(struct udev *udev) {
goto out; goto out;
} }
memset(&ep_stdin, 0, sizeof(struct epoll_event)); memzero(&ep_stdin, sizeof(struct epoll_event));
ep_stdin.events = EPOLLIN; ep_stdin.events = EPOLLIN;
ep_stdin.data.fd = STDIN_FILENO; ep_stdin.data.fd = STDIN_FILENO;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) < 0) { if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) < 0) {

2
src/udev/cdrom_id/cdrom_id.c
View file

@ -155,7 +155,7 @@ struct scsi_cmd {
static void scsi_cmd_init(struct udev *udev, struct scsi_cmd *cmd) static void scsi_cmd_init(struct udev *udev, struct scsi_cmd *cmd)
{ {
memset(cmd, 0x00, sizeof(struct scsi_cmd)); memzero(cmd, sizeof(struct scsi_cmd));
cmd->cgc.quiet = 1; cmd->cgc.quiet = 1;
cmd->cgc.sense = &cmd->_sense.s; cmd->cgc.sense = &cmd->_sense.s;
cmd->sg_io.interface_id = 'S'; cmd->sg_io.interface_id = 'S';

16
src/udev/scsi_id/scsi_serial.c
View file

@ -331,7 +331,7 @@ static int scsi_inquiry(struct udev *udev,
resend: resend:
if (dev_scsi->use_sg == 4) { if (dev_scsi->use_sg == 4) {
memset(&io_v4, 0, sizeof(struct sg_io_v4)); memzero(&io_v4, sizeof(struct sg_io_v4));
io_v4.guard = 'Q'; io_v4.guard = 'Q';
io_v4.protocol = BSG_PROTOCOL_SCSI; io_v4.protocol = BSG_PROTOCOL_SCSI;
io_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_CMD; io_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_CMD;
@ -343,7 +343,7 @@ resend:
io_v4.din_xferp = (uintptr_t)buf; io_v4.din_xferp = (uintptr_t)buf;
io_buf = (void *)&io_v4; io_buf = (void *)&io_v4;
} else { } else {
memset(&io_hdr, 0, sizeof(struct sg_io_hdr)); memzero(&io_hdr, sizeof(struct sg_io_hdr));
io_hdr.interface_id = 'S'; io_hdr.interface_id = 'S';
io_hdr.cmd_len = sizeof(inq_cmd); io_hdr.cmd_len = sizeof(inq_cmd);
io_hdr.mx_sb_len = sizeof(sense); io_hdr.mx_sb_len = sizeof(sense);
@ -410,7 +410,7 @@ static int do_scsi_page0_inquiry(struct udev *udev,
{ {
int retval; int retval;
memset(buffer, 0, len); memzero(buffer, len);
retval = scsi_inquiry(udev, dev_scsi, fd, 1, 0x0, buffer, len); retval = scsi_inquiry(udev, dev_scsi, fd, 1, 0x0, buffer, len);
if (retval < 0) if (retval < 0)
return 1; return 1;
@ -622,7 +622,7 @@ static int do_scsi_page83_inquiry(struct udev *udev,
/* also pick up the page 80 serial number */ /* also pick up the page 80 serial number */
do_scsi_page80_inquiry(udev, dev_scsi, fd, NULL, unit_serial_number, MAX_SERIAL_LEN); do_scsi_page80_inquiry(udev, dev_scsi, fd, NULL, unit_serial_number, MAX_SERIAL_LEN);
memset(page_83, 0, SCSI_INQ_BUFF_LEN); memzero(page_83, SCSI_INQ_BUFF_LEN);
retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_83, page_83, retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_83, page_83,
SCSI_INQ_BUFF_LEN); SCSI_INQ_BUFF_LEN);
if (retval < 0) if (retval < 0)
@ -709,7 +709,7 @@ static int do_scsi_page83_prespc3_inquiry(struct udev *udev,
int i, j; int i, j;
unsigned char page_83[SCSI_INQ_BUFF_LEN]; unsigned char page_83[SCSI_INQ_BUFF_LEN];
memset(page_83, 0, SCSI_INQ_BUFF_LEN); memzero(page_83, SCSI_INQ_BUFF_LEN);
retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_83, page_83, SCSI_INQ_BUFF_LEN); retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_83, page_83, SCSI_INQ_BUFF_LEN);
if (retval < 0) if (retval < 0)
return 1; return 1;
@ -773,7 +773,7 @@ static int do_scsi_page80_inquiry(struct udev *udev,
int len; int len;
unsigned char buf[SCSI_INQ_BUFF_LEN]; unsigned char buf[SCSI_INQ_BUFF_LEN];
memset(buf, 0, SCSI_INQ_BUFF_LEN); memzero(buf, SCSI_INQ_BUFF_LEN);
retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_80, buf, SCSI_INQ_BUFF_LEN); retval = scsi_inquiry(udev, dev_scsi, fd, 1, PAGE_80, buf, SCSI_INQ_BUFF_LEN);
if (retval < 0) if (retval < 0)
return retval; return retval;
@ -832,7 +832,7 @@ int scsi_std_inquiry(struct udev *udev,
sprintf(dev_scsi->kernel,"%d:%d", major(statbuf.st_rdev), sprintf(dev_scsi->kernel,"%d:%d", major(statbuf.st_rdev),
minor(statbuf.st_rdev)); minor(statbuf.st_rdev));
memset(buf, 0, SCSI_INQ_BUFF_LEN); memzero(buf, SCSI_INQ_BUFF_LEN);
err = scsi_inquiry(udev, dev_scsi, fd, 0, 0, buf, SCSI_INQ_BUFF_LEN); err = scsi_inquiry(udev, dev_scsi, fd, 0, 0, buf, SCSI_INQ_BUFF_LEN);
if (err < 0) if (err < 0)
goto out; goto out;
@ -861,7 +861,7 @@ int scsi_get_serial(struct udev *udev,
int ind; int ind;
int retval; int retval;
memset(dev_scsi->serial, 0, len); memzero(dev_scsi->serial, len);
srand((unsigned int)getpid()); srand((unsigned int)getpid());
for (cnt = 20; cnt > 0; cnt--) { for (cnt = 20; cnt > 0; cnt--) {
struct timespec duration; struct timespec duration;

2
src/udev/udev-builtin-input_id.c
View file

@ -59,7 +59,7 @@ static void get_cap_mask(struct udev_device *dev,
snprintf(text, sizeof(text), "%s", udev_device_get_sysattr_value(pdev, attr)); snprintf(text, sizeof(text), "%s", udev_device_get_sysattr_value(pdev, attr));
log_debug("%s raw kernel attribute: %s", attr, text); log_debug("%s raw kernel attribute: %s", attr, text);
memset (bitmask, 0, bitmask_size); memzero(bitmask, bitmask_size);
i = 0; i = 0;
while ((word = strrchr(text, ' ')) != NULL) { while ((word = strrchr(text, ' ')) != NULL) {
val = strtoul (word+1, NULL, 16); val = strtoul (word+1, NULL, 16);

2
src/udev/udev-ctrl.c
View file

@ -246,7 +246,7 @@ static int ctrl_send(struct udev_ctrl *uctrl, enum udev_ctrl_msg_type type, int
struct udev_ctrl_msg_wire ctrl_msg_wire; struct udev_ctrl_msg_wire ctrl_msg_wire;
int err = 0; int err = 0;
memset(&ctrl_msg_wire, 0x00, sizeof(struct udev_ctrl_msg_wire)); memzero(&ctrl_msg_wire, sizeof(struct udev_ctrl_msg_wire));
strcpy(ctrl_msg_wire.version, "udev-" VERSION); strcpy(ctrl_msg_wire.version, "udev-" VERSION);
ctrl_msg_wire.magic = UDEV_CTRL_MAGIC; ctrl_msg_wire.magic = UDEV_CTRL_MAGIC;
ctrl_msg_wire.type = type; ctrl_msg_wire.type = type;

4
src/udev/udev-event.c
View file

@ -439,7 +439,7 @@ static void spawn_read(struct udev_event *event,
} }
if (fd_stdout >= 0) { if (fd_stdout >= 0) {
memset(&ep_outpipe, 0, sizeof(struct epoll_event)); memzero(&ep_outpipe, sizeof(struct epoll_event));
ep_outpipe.events = EPOLLIN; ep_outpipe.events = EPOLLIN;
ep_outpipe.data.ptr = &fd_stdout; ep_outpipe.data.ptr = &fd_stdout;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe) < 0) { if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe) < 0) {
@ -449,7 +449,7 @@ static void spawn_read(struct udev_event *event,
} }
if (fd_stderr >= 0) { if (fd_stderr >= 0) {
memset(&ep_errpipe, 0, sizeof(struct epoll_event)); memzero(&ep_errpipe, sizeof(struct epoll_event));
ep_errpipe.events = EPOLLIN; ep_errpipe.events = EPOLLIN;
ep_errpipe.data.ptr = &fd_stderr; ep_errpipe.data.ptr = &fd_stderr;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe) < 0) { if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe) < 0) {

6
src/udev/udev-rules.c
View file

@ -870,7 +870,7 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
struct token *token = &rule_tmp->token[rule_tmp->token_cur]; struct token *token = &rule_tmp->token[rule_tmp->token_cur];
const char *attr = NULL; const char *attr = NULL;
memset(token, 0x00, sizeof(struct token)); memzero(token, sizeof(struct token));
switch (type) { switch (type) {
case TK_M_ACTION: case TK_M_ACTION:
@ -1052,7 +1052,7 @@ static int add_rule(struct udev_rules *rules, char *line,
const char *attr; const char *attr;
struct rule_tmp rule_tmp; struct rule_tmp rule_tmp;
memset(&rule_tmp, 0x00, sizeof(struct rule_tmp)); memzero(&rule_tmp, sizeof(struct rule_tmp));
rule_tmp.rules = rules; rule_tmp.rules = rules;
rule_tmp.rule.type = TK_RULE; rule_tmp.rule.type = TK_RULE;
/* the offset in the rule is limited to unsigned short */ /* the offset in the rule is limited to unsigned short */
@ -1652,7 +1652,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
strv_free(files); strv_free(files);
memset(&end_token, 0x00, sizeof(struct token)); memzero(&end_token, sizeof(struct token));
end_token.type = TK_END; end_token.type = TK_END;
add_token(rules, &end_token); add_token(rules, &end_token);
log_debug("rules contain %zu bytes tokens (%u * %zu bytes), %zu bytes strings", log_debug("rules contain %zu bytes tokens (%u * %zu bytes), %zu bytes strings",

4
src/udev/udevadm-monitor.c
View file

@ -194,7 +194,7 @@ static int adm_monitor(struct udev *udev, int argc, char *argv[])
return 2; return 2;
} }
memset(&ep_udev, 0, sizeof(struct epoll_event)); memzero(&ep_udev, sizeof(struct epoll_event));
ep_udev.events = EPOLLIN; ep_udev.events = EPOLLIN;
ep_udev.data.fd = fd_udev; ep_udev.data.fd = fd_udev;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) { if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) {
@ -228,7 +228,7 @@ static int adm_monitor(struct udev *udev, int argc, char *argv[])
return 4; return 4;
} }
memset(&ep_kernel, 0, sizeof(struct epoll_event)); memzero(&ep_kernel, sizeof(struct epoll_event));
ep_kernel.events = EPOLLIN; ep_kernel.events = EPOLLIN;
ep_kernel.data.fd = fd_kernel; ep_kernel.data.fd = fd_kernel;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_kernel, &ep_kernel) < 0) { if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_kernel, &ep_kernel) < 0) {

16
src/udev/udevd.c
View file

@ -247,12 +247,12 @@ static void worker_new(struct event *event)
goto out; goto out;
} }
memset(&ep_signal, 0, sizeof(struct epoll_event)); memzero(&ep_signal, sizeof(struct epoll_event));
ep_signal.events = EPOLLIN; ep_signal.events = EPOLLIN;
ep_signal.data.fd = fd_signal; ep_signal.data.fd = fd_signal;
fd_monitor = udev_monitor_get_fd(worker_monitor); fd_monitor = udev_monitor_get_fd(worker_monitor);
memset(&ep_monitor, 0, sizeof(struct epoll_event)); memzero(&ep_monitor, sizeof(struct epoll_event));
ep_monitor.events = EPOLLIN; ep_monitor.events = EPOLLIN;
ep_monitor.data.fd = fd_monitor; ep_monitor.data.fd = fd_monitor;
@ -303,7 +303,7 @@ static void worker_new(struct event *event)
udev_monitor_send_device(worker_monitor, NULL, dev); udev_monitor_send_device(worker_monitor, NULL, dev);
/* send udevd the result of the event execution */ /* send udevd the result of the event execution */
memset(&msg, 0, sizeof(struct worker_message)); memzero(&msg, sizeof(struct worker_message));
if (err != 0) if (err != 0)
msg.exitcode = err; msg.exitcode = err;
msg.pid = getpid(); msg.pid = getpid();
@ -1159,23 +1159,23 @@ int main(int argc, char *argv[])
goto exit; goto exit;
} }
memset(&ep_ctrl, 0, sizeof(struct epoll_event)); memzero(&ep_ctrl, sizeof(struct epoll_event));
ep_ctrl.events = EPOLLIN; ep_ctrl.events = EPOLLIN;
ep_ctrl.data.fd = fd_ctrl; ep_ctrl.data.fd = fd_ctrl;
memset(&ep_inotify, 0, sizeof(struct epoll_event)); memzero(&ep_inotify, sizeof(struct epoll_event));
ep_inotify.events = EPOLLIN; ep_inotify.events = EPOLLIN;
ep_inotify.data.fd = fd_inotify; ep_inotify.data.fd = fd_inotify;
memset(&ep_signal, 0, sizeof(struct epoll_event)); memzero(&ep_signal, sizeof(struct epoll_event));
ep_signal.events = EPOLLIN; ep_signal.events = EPOLLIN;
ep_signal.data.fd = fd_signal; ep_signal.data.fd = fd_signal;
memset(&ep_netlink, 0, sizeof(struct epoll_event)); memzero(&ep_netlink, sizeof(struct epoll_event));
ep_netlink.events = EPOLLIN; ep_netlink.events = EPOLLIN;
ep_netlink.data.fd = fd_netlink; ep_netlink.data.fd = fd_netlink;
memset(&ep_worker, 0, sizeof(struct epoll_event)); memzero(&ep_worker, sizeof(struct epoll_event));
ep_worker.events = EPOLLIN; ep_worker.events = EPOLLIN;
ep_worker.data.fd = fd_worker; ep_worker.data.fd = fd_worker;