rocker: Use g_new() & friends where that makes obvious sense
PATCH 1/1 rocker: Use g_new() & friends where that makes obvious sense
g_new(T, n) is neater than g_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowing size_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.
This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
--- hw/net/rocker/rocker.c | 2 +- hw/net/rocker/rocker_desc.c | 4 ++-- hw/net/rocker/rocker_fp.c | 2 +- hw/net/rocker/rocker_of_dpa.c | 9 ++++----- 4 files changed, 8 insertions(+), 9 deletions(-)
hw/net/rocker/rocker.c +1 -1
@@ -1362,7 +1362,7 @@ static int pci_rocker_init(PCIDevice *dev) r->fp_ports =ROCKER_FP_PORTS_MAX ; } - r->rings =g_malloc (sizeof (DescRing *) *rocker_pci_ring_count (r)); + r->rings = g_new(DescRing *, rocker_pci_ring_count(r));if (!r->rings) { goto err_rings_alloc; }
hw/net/rocker/rocker_desc.c +2 -2
@@ -142,7 +142,7 @@ bool desc_ring_set_size(DescRing *ring, uint32_t size) ring->size = size; ring->head = ring->tail =0 ; - ring->info =g_realloc (ring->info, size *sizeof (DescInfo)); + ring->info =g_renew (DescInfo, ring->info, size);if (!ring->info) {return false; }
@@ -345,7 +345,7 @@ DescRing *desc_ring_alloc(Rocker *r, int index) {DescRing *ring; - ring =g_malloc0 (sizeof (DescRing)); + ring =g_new0 (DescRing,1 );if (!ring) {return NULL ; }
hw/net/rocker/rocker_fp.c +1 -1
@@ -218,7 +218,7 @@ FpPort *fp_port_alloc(Rocker *r, char *sw_name, MACAddr *start_mac, unsigned int index, NICPeers *peers) { - FpPort *port = g_malloc0(sizeof(FpPort)); + FpPort *port = g_new0(FpPort, 1);if (!port) {return NULL ;
hw/net/rocker/rocker_of_dpa.c +4 -5
@@ -367,7 +367,7 @@ static OfDpaFlow *of_dpa_flow_alloc(uint64_t cookie)OfDpaFlow *flow;int64_t now =qemu_clock_get_ms (QEMU_CLOCK_VIRTUAL ) /1000 ; - flow =g_malloc0 (sizeof (OfDpaFlow)); + flow =g_new0 (OfDpaFlow,1 );if (!flow) {return NULL ; }
@@ -811,7 +811,7 @@ static int of_dpa_group_get_stats(OfDpa *of_dpa, uint32_t id)static OfDpaGroup *of_dpa_group_alloc (uint32_t id) { -OfDpaGroup *group =g_malloc0 (sizeof (OfDpaGroup)); +OfDpaGroup *group =g_new0 (OfDpaGroup,1 );if (!group) {return NULL ;
@@ -2039,15 +2039,14 @@ static int of_dpa_cmd_add_l2_flood(OfDpa *of_dpa, OfDpaGroup *group, group->l2_flood.group_count =rocker_tlv_get_le16 (group_tlvs[ROCKER_TLV_OF_DPA_GROUP_COUNT ]); - tlvs =g_malloc0 ((group->l2_flood.group_count +1 ) * -sizeof (RockerTlv *)); + tlvs = g_new0(RockerTlv *, group->l2_flood.group_count + 1);if (!tlvs) {return -ROCKER_ENOMEM ; }g_free (group->l2_flood.group_ids); group->l2_flood.group_ids = -g_malloc0 (group->l2_flood.group_count *sizeof (uint32_t )); +g_new0 (uint32_t, group->l2_flood.group_count);if (!group->l2_flood.group_ids) { err = -ROCKER_ENOMEM ; goto err_out;
Signature · 1 line
2.4.3
Quoted 7 lines · Mon, Sep 14, 2015 at 01:52:23PM CEST, [email protected] wrote:
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
^ typo :)
Other than that:
Eric Blake
Reviewed-byQuoted 11 lines · Jiri Pirko
Quoted 7 lines · Mon, Sep 14, 2015 at 01:52:23PM CEST, [email protected] wrote:
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
^ typo :)
This typo is copy-pasted into ALL of your recent g_new() cleanups. Since you did scattershot threads across multiple maintainers rather than one big thread, it may be a bit harder to plug all the instances before they get pulled through the various trees.
Quoted 4 lines
Other than that:
Acked-by Jiri Pirko <[email protected]>
[In qemu, we tend to use 'Reviewed-by' for "I've inspected the code and agree it correctly does what the commit message claims", and the weaker 'Acked-by' for "I agree with the fix as documented in the commit message but didn't inspect the code to ensure that they match"]
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Quoted 7 lines · Eric Blake
Quoted 6 lines · Jiri Pirko
Quoted 5 lines · Mon, Sep 14, 2015 at 01:52:23PM CEST, [email protected] wrote:
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.
Quoted 7 lines
Quoted 5 lines
Quoted 2 lines
This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
^ typo :)This typo is copy-pasted into ALL of your recent
g_new()cleanups.
Actually, not all of them.
And when I first read your report of the typo, I was thinking that it meant 'patches', although now I see that it should be two words 'patch as'.
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Quoted 10 lines · Eric Blake
Quoted 9 lines · Jiri Pirko
Quoted 7 lines · Mon, Sep 14, 2015 at 01:52:23PM CEST, [email protected] wrote:
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
Quoted 7 lines
Quoted 2 lines
^ typo :)This typo is copy-pasted into ALL of your recent
g_new()cleanups. Since you did scattershot threads across multiple maintainers rather than one big thread, it may be a bit harder to plug all the instances before they get pulled through the various trees.
Only three of them, actually: this one, linux-user and qemu-char.
[...]
Jiri Pirko
Reviewed-byQuoted 21 lines · Mon, Sep 14, 2015 at 05:55:40PM CEST, [email protected] wrote:
Quoted 11 lines · Jiri Pirko
Quoted 7 lines · Mon, Sep 14, 2015 at 01:52:23PM CEST, [email protected] wrote:
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
^ typo :)This typo is copy-pasted into ALL of your recent
g_new()cleanups. Since you did scattershot threads across multiple maintainers rather than one big thread, it may be a bit harder to plug all the instances before they get pulled through the various trees.Quoted 3 lines
Other than that:
Quoted 8 lines
Quoted 1 line
Acked-by Jiri Pirko <[email protected]>Reviewed-by Eric Blake <[email protected]>[In qemu, we tend to use 'Reviewed-by' for "I've inspected the code and agree it correctly does what the commit message claims", and the weaker 'Acked-by' for "I agree with the fix as documented in the commit message but didn't inspect the code to ensure that they match"]
Michael, could you take this one through trivial? Assuming Scott and Jiri don't mind, and with s/patchas/patch as/ in the commit message.
Quoted 9 lines · Markus Armbruster
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.This commit only touches allocations with size arguments of the form sizeof(T). Same Coccinelle semantic patchas in commit b45c03f.
Signed-off-by Markus Armbruster <[email protected]>
Quoted 2 lines · Thu, Sep 24, 2015 at 06:18:43PM CEST, [email protected] wrote:
Michael, could you take this one through trivial? Assuming Scott and Jiri don't mind, and with s/patchas/patch as/ in the commit message.
I don't mind :)
Michael Tokarev
AppliedQuoted 9 lines · Markus Armbruster
Michael, could you take this one through trivial? Assuming Scott and Jiri don't mind, and with s/patchas/patch as/ in the commit message.
Quoted 4 lines · Markus Armbruster
g_new(T, n)is neater thang_malloc(sizeof(T) * n). It's also safer, for two reasons. One, it catches multiplication overflowingsize_t. Two, it returns T * rather than void *, which lets the compiler catch more type errors.
Applied to -trivial, thanks!
/mjt