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

caif: Remove OOM messages, use kzalloc

Remove per site OOM messages because they duplicate
the generic mm subsystem OOM message.

Use kzalloc instead of kmalloc/memset
when next to the OOM message removals.

Reduces object size (allyesconfig ~2%)

$ size -t drivers/net/caif/built-in.o.old net/caif/built-in.o.old
text data bss dec hex filename
32297 700 8224 41221 a105 drivers/net/caif/built-in.o.old
72159 1317 20552 94028 16f4c net/caif/built-in.o.old
104456 2017 28776 135249 21051 (TOTALS)
$ size -t drivers/net/caif/built-in.o.new net/caif/built-in.o.new
text data bss dec hex filename
31975 700 8184 40859 9f9b drivers/net/caif/built-in.o.new
70748 1317 20152 92217 16839 net/caif/built-in.o.new
102723 2017 28336 133076 207d4 (TOTALS)

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Joe Perches and committed by
David S. Miller 7ac2ed0c 343e43c0

+28 -87
+1 -8
drivers/net/caif/caif_hsi.c
··· 937 937 int res; 938 938 939 939 ndev = alloc_netdev(sizeof(struct cfhsi), "cfhsi%d", cfhsi_setup); 940 - if (!ndev) { 941 - dev_err(&pdev->dev, "%s: alloc_netdev failed.\n", 942 - __func__); 940 + if (!ndev) 943 941 return -ENODEV; 944 - } 945 942 946 943 cfhsi = netdev_priv(ndev); 947 944 cfhsi->ndev = ndev; ··· 966 969 */ 967 970 cfhsi->tx_buf = kzalloc(CFHSI_BUF_SZ_TX, GFP_KERNEL); 968 971 if (!cfhsi->tx_buf) { 969 - dev_err(&ndev->dev, "%s: Failed to allocate TX buffer.\n", 970 - __func__); 971 972 res = -ENODEV; 972 973 goto err_alloc_tx; 973 974 } ··· 976 981 */ 977 982 cfhsi->rx_buf = kzalloc(CFHSI_BUF_SZ_RX, GFP_KERNEL); 978 983 if (!cfhsi->rx_buf) { 979 - dev_err(&ndev->dev, "%s: Failed to allocate RX buffer.\n", 980 - __func__); 981 984 res = -ENODEV; 982 985 goto err_alloc_rx; 983 986 }
-4
drivers/net/caif/caif_spi.c
··· 664 664 /* Allocate DMA buffers. */ 665 665 cfspi->xfer.va_tx = dma_alloc(&cfspi->xfer.pa_tx); 666 666 if (!cfspi->xfer.va_tx) { 667 - printk(KERN_WARNING 668 - "CFSPI: failed to allocate dma TX buffer.\n"); 669 667 res = -ENODEV; 670 668 goto err_dma_alloc_tx; 671 669 } ··· 671 673 cfspi->xfer.va_rx = dma_alloc(&cfspi->xfer.pa_rx); 672 674 673 675 if (!cfspi->xfer.va_rx) { 674 - printk(KERN_WARNING 675 - "CFSPI: failed to allocate dma TX buffer.\n"); 676 676 res = -ENODEV; 677 677 goto err_dma_alloc_rx; 678 678 }
+3 -12
net/caif/cfcnfg.c
··· 78 78 79 79 /* Initiate this layer */ 80 80 this = kzalloc(sizeof(struct cfcnfg), GFP_ATOMIC); 81 - if (!this) { 82 - pr_warn("Out of memory\n"); 81 + if (!this) 83 82 return NULL; 84 - } 85 83 this->mux = cfmuxl_create(); 86 84 if (!this->mux) 87 85 goto out_of_mem; ··· 106 108 107 109 return this; 108 110 out_of_mem: 109 - pr_warn("Out of memory\n"); 110 - 111 111 synchronize_rcu(); 112 112 113 113 kfree(this->mux); ··· 444 448 "- unknown channel type\n"); 445 449 goto unlock; 446 450 } 447 - if (!servicel) { 448 - pr_warn("Out of memory\n"); 451 + if (!servicel) 449 452 goto unlock; 450 - } 451 453 layer_set_dn(servicel, cnfg->mux); 452 454 cfmuxl_set_uplayer(cnfg->mux, servicel, channel_id); 453 455 layer_set_up(servicel, adapt_layer); ··· 491 497 case CFPHYTYPE_FRAG: 492 498 phy_driver = 493 499 cfserl_create(CFPHYTYPE_FRAG, phyid, stx); 494 - if (!phy_driver) { 495 - pr_warn("Out of memory\n"); 500 + if (!phy_driver) 496 501 goto out; 497 - } 498 502 break; 499 503 case CFPHYTYPE_CAIF: 500 504 phy_driver = NULL; ··· 513 521 frml = cffrml_create(phyid, fcs); 514 522 515 523 if (!frml) { 516 - pr_warn("Out of memory\n"); 517 524 kfree(phyinfo); 518 525 goto out; 519 526 }
+6 -17
net/caif/cfctrl.c
··· 35 35 { 36 36 struct dev_info dev_info; 37 37 struct cfctrl *this = 38 - kmalloc(sizeof(struct cfctrl), GFP_ATOMIC); 39 - if (!this) { 40 - pr_warn("Out of memory\n"); 38 + kzalloc(sizeof(struct cfctrl), GFP_ATOMIC); 39 + if (!this) 41 40 return NULL; 42 - } 43 41 caif_assert(offsetof(struct cfctrl, serv.layer) == 0); 44 42 memset(&dev_info, 0, sizeof(dev_info)); 45 43 dev_info.id = 0xff; 46 - memset(this, 0, sizeof(*this)); 47 44 cfsrvl_init(&this->serv, 0, &dev_info, false); 48 45 atomic_set(&this->req_seq_no, 1); 49 46 atomic_set(&this->rsp_seq_no, 1); ··· 177 180 struct cfctrl *cfctrl = container_obj(layer); 178 181 struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN); 179 182 struct cflayer *dn = cfctrl->serv.layer.dn; 180 - if (!pkt) { 181 - pr_warn("Out of memory\n"); 183 + if (!pkt) 182 184 return; 183 - } 184 185 if (!dn) { 185 186 pr_debug("not able to send enum request\n"); 186 187 return; ··· 219 224 } 220 225 221 226 pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN); 222 - if (!pkt) { 223 - pr_warn("Out of memory\n"); 227 + if (!pkt) 224 228 return -ENOMEM; 225 - } 226 229 cfpkt_addbdy(pkt, CFCTRL_CMD_LINK_SETUP); 227 230 cfpkt_addbdy(pkt, (param->chtype << 4) | param->linktype); 228 231 cfpkt_addbdy(pkt, (param->priority << 3) | param->phyid); ··· 268 275 return -EINVAL; 269 276 } 270 277 req = kzalloc(sizeof(*req), GFP_KERNEL); 271 - if (!req) { 272 - pr_warn("Out of memory\n"); 278 + if (!req) 273 279 return -ENOMEM; 274 - } 275 280 req->client_layer = user_layer; 276 281 req->cmd = CFCTRL_CMD_LINK_SETUP; 277 282 req->param = *param; ··· 303 312 struct cfpkt *pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN); 304 313 struct cflayer *dn = cfctrl->serv.layer.dn; 305 314 306 - if (!pkt) { 307 - pr_warn("Out of memory\n"); 315 + if (!pkt) 308 316 return -ENOMEM; 309 - } 310 317 311 318 if (!dn) { 312 319 pr_debug("not able to send link-down request\n");
+2 -5
net/caif/cfdbgl.c
··· 19 19 20 20 struct cflayer *cfdbgl_create(u8 channel_id, struct dev_info *dev_info) 21 21 { 22 - struct cfsrvl *dbg = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 23 - if (!dbg) { 24 - pr_warn("Out of memory\n"); 22 + struct cfsrvl *dbg = kzalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 23 + if (!dbg) 25 24 return NULL; 26 - } 27 25 caif_assert(offsetof(struct cfsrvl, layer) == 0); 28 - memset(dbg, 0, sizeof(struct cfsrvl)); 29 26 cfsrvl_init(dbg, channel_id, dev_info, false); 30 27 dbg->layer.receive = cfdbgl_receive; 31 28 dbg->layer.transmit = cfdbgl_transmit;
+2 -5
net/caif/cfdgml.c
··· 26 26 27 27 struct cflayer *cfdgml_create(u8 channel_id, struct dev_info *dev_info) 28 28 { 29 - struct cfsrvl *dgm = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 30 - if (!dgm) { 31 - pr_warn("Out of memory\n"); 29 + struct cfsrvl *dgm = kzalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 30 + if (!dgm) 32 31 return NULL; 33 - } 34 32 caif_assert(offsetof(struct cfsrvl, layer) == 0); 35 - memset(dgm, 0, sizeof(struct cfsrvl)); 36 33 cfsrvl_init(dgm, channel_id, dev_info, true); 37 34 dgm->layer.receive = cfdgml_receive; 38 35 dgm->layer.transmit = cfdgml_transmit;
+2 -5
net/caif/cffrml.c
··· 34 34 static u32 cffrml_rcv_checsum_error; 35 35 struct cflayer *cffrml_create(u16 phyid, bool use_fcs) 36 36 { 37 - struct cffrml *this = kmalloc(sizeof(struct cffrml), GFP_ATOMIC); 38 - if (!this) { 39 - pr_warn("Out of memory\n"); 37 + struct cffrml *this = kzalloc(sizeof(struct cffrml), GFP_ATOMIC); 38 + if (!this) 40 39 return NULL; 41 - } 42 40 this->pcpu_refcnt = alloc_percpu(int); 43 41 if (this->pcpu_refcnt == NULL) { 44 42 kfree(this); ··· 45 47 46 48 caif_assert(offsetof(struct cffrml, layer) == 0); 47 49 48 - memset(this, 0, sizeof(struct cflayer)); 49 50 this->layer.receive = cffrml_receive; 50 51 this->layer.transmit = cffrml_transmit; 51 52 this->layer.ctrlcmd = cffrml_ctrlcmd;
+2 -5
net/caif/cfrfml.c
··· 46 46 int mtu_size) 47 47 { 48 48 int tmp; 49 - struct cfrfml *this = 50 - kzalloc(sizeof(struct cfrfml), GFP_ATOMIC); 49 + struct cfrfml *this = kzalloc(sizeof(struct cfrfml), GFP_ATOMIC); 51 50 52 - if (!this) { 53 - pr_warn("Out of memory\n"); 51 + if (!this) 54 52 return NULL; 55 - } 56 53 57 54 cfsrvl_init(&this->serv, channel_id, dev_info, false); 58 55 this->serv.release = cfrfml_release;
+2 -5
net/caif/cfserl.c
··· 33 33 34 34 struct cflayer *cfserl_create(int type, int instance, bool use_stx) 35 35 { 36 - struct cfserl *this = kmalloc(sizeof(struct cfserl), GFP_ATOMIC); 37 - if (!this) { 38 - pr_warn("Out of memory\n"); 36 + struct cfserl *this = kzalloc(sizeof(struct cfserl), GFP_ATOMIC); 37 + if (!this) 39 38 return NULL; 40 - } 41 39 caif_assert(offsetof(struct cfserl, layer) == 0); 42 - memset(this, 0, sizeof(struct cfserl)); 43 40 this->layer.receive = cfserl_receive; 44 41 this->layer.transmit = cfserl_transmit; 45 42 this->layer.ctrlcmd = cfserl_ctrlcmd;
+2 -6
net/caif/cfsrvl.c
··· 108 108 struct caif_payload_info *info; 109 109 u8 flow_on = SRVL_FLOW_ON; 110 110 pkt = cfpkt_create(SRVL_CTRL_PKT_SIZE); 111 - if (!pkt) { 112 - pr_warn("Out of memory\n"); 111 + if (!pkt) 113 112 return -ENOMEM; 114 - } 115 113 116 114 if (cfpkt_add_head(pkt, &flow_on, 1) < 0) { 117 115 pr_err("Packet is erroneous!\n"); ··· 128 130 struct caif_payload_info *info; 129 131 u8 flow_off = SRVL_FLOW_OFF; 130 132 pkt = cfpkt_create(SRVL_CTRL_PKT_SIZE); 131 - if (!pkt) { 132 - pr_warn("Out of memory\n"); 133 + if (!pkt) 133 134 return -ENOMEM; 134 - } 135 135 136 136 if (cfpkt_add_head(pkt, &flow_off, 1) < 0) { 137 137 pr_err("Packet is erroneous!\n");
+2 -5
net/caif/cfutill.c
··· 26 26 27 27 struct cflayer *cfutill_create(u8 channel_id, struct dev_info *dev_info) 28 28 { 29 - struct cfsrvl *util = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 30 - if (!util) { 31 - pr_warn("Out of memory\n"); 29 + struct cfsrvl *util = kzalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 30 + if (!util) 32 31 return NULL; 33 - } 34 32 caif_assert(offsetof(struct cfsrvl, layer) == 0); 35 - memset(util, 0, sizeof(struct cfsrvl)); 36 33 cfsrvl_init(util, channel_id, dev_info, true); 37 34 util->layer.receive = cfutill_receive; 38 35 util->layer.transmit = cfutill_transmit;
+2 -5
net/caif/cfveil.c
··· 25 25 26 26 struct cflayer *cfvei_create(u8 channel_id, struct dev_info *dev_info) 27 27 { 28 - struct cfsrvl *vei = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 29 - if (!vei) { 30 - pr_warn("Out of memory\n"); 28 + struct cfsrvl *vei = kzalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 29 + if (!vei) 31 30 return NULL; 32 - } 33 31 caif_assert(offsetof(struct cfsrvl, layer) == 0); 34 - memset(vei, 0, sizeof(struct cfsrvl)); 35 32 cfsrvl_init(vei, channel_id, dev_info, true); 36 33 vei->layer.receive = cfvei_receive; 37 34 vei->layer.transmit = cfvei_transmit;
+2 -5
net/caif/cfvidl.c
··· 21 21 22 22 struct cflayer *cfvidl_create(u8 channel_id, struct dev_info *dev_info) 23 23 { 24 - struct cfsrvl *vid = kmalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 25 - if (!vid) { 26 - pr_warn("Out of memory\n"); 24 + struct cfsrvl *vid = kzalloc(sizeof(struct cfsrvl), GFP_ATOMIC); 25 + if (!vid) 27 26 return NULL; 28 - } 29 27 caif_assert(offsetof(struct cfsrvl, layer) == 0); 30 28 31 - memset(vid, 0, sizeof(struct cfsrvl)); 32 29 cfsrvl_init(vid, channel_id, dev_info, false); 33 30 vid->layer.receive = cfvidl_receive; 34 31 vid->layer.transmit = cfvidl_transmit;