loader/efi: Make gcc friendlier by move md_dev

[imp]

Summary

Move the extern struct devsw md_dev out of the function. gcc is happier.

Sponsored by: Netflix

stand/efi/loader/main.c

tool_mw_write_fn(struct sysctl_oid *oidp, struct sysctl_req *req,
         else if (cmd == 'W')
                 goto write;
         else
                 goto out;
 
 write:
         data_buf_size = *buf_size;
         data_buf = malloc(data_buf_size, M_NTB_TOOL, M_WAITOK | M_ZERO);
-        if (!data_buf) {
-                rc = ENOMEM;
-                goto out;
-        }
 
         if (s_pflag)
                 memset(data_buf, pattern, data_buf_size);
         else
                 arc4rand(data_buf, data_buf_size, 1);
 
         memcpy(write_buf + *buf_offset, data_buf, data_buf_size);
 
if (rc)
                 device_printf(tc->dev, "Local port sysctl set failed with err="
                     "(%d).\n", rc);
         else
                 tc->port_no = local_port;
 
         return (rc);
 }
 
-static int
+static void
 tool_init_peers(struct tool_ctx *tc)
 {
         int pidx;
 
         tc->peer_cnt = ntb_peer_port_count(tc->dev);
         tc->peers = malloc(tc->peer_cnt * sizeof(*tc->peers), M_NTB_TOOL,
             M_WAITOK | M_ZERO);
-        if (tc->peers == NULL)
-                return (ENOMEM);
         for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
                 tc->peers[pidx].pidx = pidx;
                 tc->peers[pidx].tc = tc;
         }
-
-        return (0);
 }
 
 static void
 tool_clear_peers(struct tool_ctx *tc)
 {
 
         free(tc->peers, M_NTB_TOOL);
 }
tool_init_mws(struct tool_ctx *tc)
         int widx, pidx, rc;
 
         /* Initialize inbound memory windows and outbound MWs wrapper */
         for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
                 tc->peers[pidx].inmw_cnt = ntb_mw_count(tc->dev);
                 tc->peers[pidx].inmws = malloc(tc->peers[pidx].inmw_cnt *
                     sizeof(*tc->peers[pidx].inmws), M_NTB_TOOL,
                     M_WAITOK | M_ZERO);
-                if (tc->peers[pidx].inmws == NULL)
-                        return (ENOMEM);
 
                 for (widx = 0; widx < tc->peers[pidx].inmw_cnt; widx++) {
                         mw = &tc->peers[pidx].inmws[widx];
                         memset((void *)mw, 0, sizeof(*mw));
                         mw->tc = tc;
                         mw->widx = widx;
                         mw->pidx = pidx;
                         mw->mw_buf_offset = DEFAULT_MW_OFF;
sysctl_peer_spad_handle(SYSCTL_HANDLER_ARGS)
         if (rc == 0) {
                 sscanf(buf, "%i", &bits);
                 return ntb_peer_spad_write(tc->dev, sidx, bits);
         }
 
         return (rc);
 }
 
-static int
+static void
 tool_init_spads(struct tool_ctx *tc)
 {
         int sidx, pidx;
 
         /* Initialize inbound scratchpad structures */
         tc->inspad_cnt = ntb_spad_count(tc->dev);
         tc->inspads = malloc(tc->inspad_cnt * sizeof(*tc->inspads), M_NTB_TOOL,
             M_WAITOK | M_ZERO);
-        if (tc->inspads == NULL)
-                return (ENOMEM);
 
         for (sidx = 0; sidx < tc->inspad_cnt; sidx++) {
                 tc->inspads[sidx].sidx = sidx;
                 tc->inspads[sidx].pidx = -1;
                 tc->inspads[sidx].tc = tc;
         }
 
         /* Initialize outbound scratchpad structures */
         for (pidx = 0; pidx < tc->peer_cnt; pidx++) {
                 tc->peers[pidx].outspad_cnt = ntb_spad_count(tc->dev);
                 tc->peers[pidx].outspads =  malloc(tc->peers[pidx].outspad_cnt *
                     sizeof(*tc->peers[pidx].outspads), M_NTB_TOOL, M_WAITOK |
                     M_ZERO);
-                if (tc->peers[pidx].outspads == NULL)
-                        return (ENOMEM);
 
                 for (sidx = 0; sidx < tc->peers[pidx].outspad_cnt; sidx++) {
                         tc->peers[pidx].outspads[sidx].sidx = sidx;
                         tc->peers[pidx].outspads[sidx].pidx = pidx;
                         tc->peers[pidx].outspads[sidx].tc = tc;
                 }
         }
-
-        return (0);
 }
 
 static void
 tool_clear_spads(struct tool_ctx *tc)
 {
         int pidx;
 
         /* Free local inspads. */
ntb_tool_attach(device_t dev)
         struct tool_ctx *tc = device_get_softc(dev);
         int rc = 0;
 
         tc->dev = dev;
         rc = tool_check_ntb(tc);
         if (rc)
                 goto out;
 
-        rc = tool_init_peers(tc);
-        if (rc)
-                goto err_clear_data;
+        tool_init_peers(tc);
 
         rc = tool_init_mws(tc);
         if (rc)
                 goto err_clear_data;
 
-        rc = tool_init_spads(tc);
-        if (rc)
-                goto err_clear_mws;
+        tool_init_spads(tc);
 
         rc = tool_init_ntb(tc);
         if (rc)
                 goto err_clear_spads;
 
         tool_setup_sysctl(tc);
 
         return (0);
 
 err_clear_spads:
         tool_clear_spads(tc);
-err_clear_mws:
         tool_clear_mws(tc);
         tool_clear_peers(tc);
 err_clear_data:
         tool_clear_data(tc);
 out:
         device_printf(dev, "ntb_tool attached failed with err=(%d).\n", rc);
         return (rc);
 }