u32 port_num = entry->attr.port_num;
        struct ib_gid_table *table = rdma_gid_table(device, port_num);
 
-       dev_dbg(&device->dev, "%s port=%u index=%d gid %pI6\n", __func__,
+       dev_dbg(&device->dev, "%s port=%u index=%u gid %pI6\n", __func__,
                port_num, entry->attr.index, entry->attr.gid.raw);
 
        write_lock_irq(&table->rwlock);
 {
        entry->state = GID_TABLE_ENTRY_VALID;
 
-       dev_dbg(&entry->attr.device->dev, "%s port=%d index=%d gid %pI6\n",
+       dev_dbg(&entry->attr.device->dev, "%s port=%u index=%u gid %pI6\n",
                __func__, entry->attr.port_num, entry->attr.index,
                entry->attr.gid.raw);
 
        int ret;
 
        if (!attr->ndev) {
-               dev_err(&attr->device->dev, "%s NULL netdev port=%d index=%d\n",
+               dev_err(&attr->device->dev, "%s NULL netdev port=%u index=%u\n",
                        __func__, attr->port_num, attr->index);
                return -EINVAL;
        }
                ret = attr->device->ops.add_gid(attr, &entry->context);
                if (ret) {
                        dev_err(&attr->device->dev,
-                               "%s GID add failed port=%d index=%d\n",
+                               "%s GID add failed port=%u index=%u\n",
                                __func__, attr->port_num, attr->index);
                        return ret;
                }
                        continue;
                if (kref_read(&table->data_vec[i]->kref) > 1) {
                        dev_err(&device->dev,
-                               "GID entry ref leak for index %d ref=%d\n", i,
+                               "GID entry ref leak for index %d ref=%u\n", i,
                                kref_read(&table->data_vec[i]->kref));
                        leak = true;
                }
 
 
        ret = ib_get_cached_pkey(ib_dev, port_num, pkey_index, &pkey);
        if (ret) {
-               dev_warn_ratelimited(&ib_dev->dev, "ib_cm: Couldn't retrieve pkey for incoming request (port %d, pkey index %d). %d\n",
+               dev_warn_ratelimited(&ib_dev->dev, "ib_cm: Couldn't retrieve pkey for incoming request (port %u, pkey index %u). %d\n",
                                     port_num, pkey_index, ret);
                return 0;
        }
 
        ret = iwpm_wait_complete_req(nlmsg_request);
        return ret;
 pid_query_error:
-       pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
+       pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
        dev_kfree_skb(skb);
        if (nlmsg_request)
                iwpm_free_nlmsg_request(&nlmsg_request->kref);
        ret = iwpm_wait_complete_req(nlmsg_request);
        return ret;
 add_mapping_error:
-       pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
+       pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
 add_mapping_error_nowarn:
        dev_kfree_skb(skb);
        if (nlmsg_request)
        ret = iwpm_wait_complete_req(nlmsg_request);
        return ret;
 query_mapping_error:
-       pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
+       pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
 query_mapping_error_nowarn:
        dev_kfree_skb(skb);
        if (nlmsg_request)
                        "remove_mapping: Local sockaddr:");
        return 0;
 remove_mapping_error:
-       pr_info("%s: %s (client = %d)\n", __func__, err_str, nl_client);
+       pr_info("%s: %s (client = %u)\n", __func__, err_str, nl_client);
        if (skb)
                dev_kfree_skb_any(skb);
        return ret;
                        strcmp(iwpm_ulib_name, iwpm_name) ||
                        iwpm_version < IWPM_UABI_VERSION_MIN) {
 
-               pr_info("%s: Incorrect info (dev = %s name = %s version = %d)\n",
+               pr_info("%s: Incorrect info (dev = %s name = %s version = %u)\n",
                                __func__, dev_name, iwpm_name, iwpm_version);
                nlmsg_request->err_code = IWPM_USER_LIB_INFO_ERR;
                goto register_pid_response_exit;
        iwpm_user_pid = cb->nlh->nlmsg_pid;
        iwpm_ulib_version = iwpm_version;
        if (iwpm_ulib_version < IWPM_UABI_VERSION)
-               pr_warn_once("%s: Down level iwpmd/pid %u.  Continuing...",
+               pr_warn_once("%s: Down level iwpmd/pid %d.  Continuing...",
                        __func__, iwpm_user_pid);
        atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
        pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
 
        nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
        if (!iwpm_valid_client(nl_client)) {
-               pr_info("%s: Invalid port mapper client = %d\n",
+               pr_info("%s: Invalid port mapper client = %u\n",
                                __func__, nl_client);
                return ret;
        }
        iwpm_version = nla_get_u16(nltb[IWPM_NLA_MAPINFO_ULIB_VER]);
        if (strcmp(iwpm_ulib_name, iwpm_name) ||
                        iwpm_version < IWPM_UABI_VERSION_MIN) {
-               pr_info("%s: Invalid port mapper name = %s version = %d\n",
+               pr_info("%s: Invalid port mapper name = %s version = %u\n",
                                __func__, iwpm_name, iwpm_version);
                return ret;
        }
        nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
        if (!iwpm_valid_client(nl_client)) {
-               pr_info("%s: Invalid port mapper client = %d\n",
+               pr_info("%s: Invalid port mapper client = %u\n",
                                __func__, nl_client);
                return ret;
        }
        iwpm_user_pid = cb->nlh->nlmsg_pid;
 
        if (iwpm_ulib_version < IWPM_UABI_VERSION)
-               pr_warn_once("%s: Down level iwpmd/pid %u.  Continuing...",
+               pr_warn_once("%s: Down level iwpmd/pid %d.  Continuing...",
                        __func__, iwpm_user_pid);
 
        if (!iwpm_mapinfo_available())
        abi_version = nla_get_u16(nltb[IWPM_NLA_HELLO_ABI_VERSION]);
        nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type);
        if (!iwpm_valid_client(nl_client)) {
-               pr_info("%s: Invalid port mapper client = %d\n",
+               pr_info("%s: Invalid port mapper client = %u\n",
                                __func__, nl_client);
                return ret;
        }
 
        int ret = -EINVAL;
 
        if (!iwpm_valid_client(nl_client)) {
-               pr_info("%s: Invalid client = %d\n", __func__, nl_client);
+               pr_info("%s: Invalid client = %u\n", __func__, nl_client);
                return ret;
        }
        spin_lock_irqsave(&iwpm_reminfo_lock, flags);
                err_str = "Unable to send a nlmsg";
                goto mapinfo_num_error;
        }
-       pr_debug("%s: Sent mapping number = %d\n", __func__, mapping_num);
+       pr_debug("%s: Sent mapping number = %u\n", __func__, mapping_num);
        return 0;
 mapinfo_num_error:
        pr_info("%s: %s\n", __func__, err_str);
 
        /* Validate device and port */
        port_priv = ib_get_mad_port(device, port_num);
        if (!port_priv) {
-               dev_dbg_ratelimited(&device->dev, "%s: Invalid port %d\n",
+               dev_dbg_ratelimited(&device->dev, "%s: Invalid port %u\n",
                                    __func__, port_num);
                ret = ERR_PTR(-ENODEV);
                goto error1;
        /* Make sure MAD base version is understood */
        if (mad_hdr->base_version != IB_MGMT_BASE_VERSION &&
            (!opa || mad_hdr->base_version != OPA_MGMT_BASE_VERSION)) {
-               pr_err("MAD received with unsupported base version %d %s\n",
+               pr_err("MAD received with unsupported base version %u %s\n",
                       mad_hdr->base_version, opa ? "(opa)" : "");
                goto out;
        }
 
        /* It's worse than that! He's dead, Jim! */
        dev_err(&qp_info->port_priv->device->dev,
-               "Fatal error (%d) on MAD QP (%d)\n",
+               "Fatal error (%d) on MAD QP (%u)\n",
                event->event, qp_info->qp->qp_num);
 }
 
 
                if (ib_agent_port_close(device, i))
                        dev_err(&device->dev,
-                               "Couldn't close port %d for agents\n", i);
+                               "Couldn't close port %u for agents\n", i);
                if (ib_mad_port_close(device, i))
-                       dev_err(&device->dev, "Couldn't close port %d\n", i);
+                       dev_err(&device->dev, "Couldn't close port %u\n", i);
        }
 }
 
 
                 */
                up_read(&rdma_nl_types[type].sem);
 
-               request_module("rdma-netlink-subsys-%d", type);
+               request_module("rdma-netlink-subsys-%u", type);
 
                down_read(&rdma_nl_types[type].sem);
                cb_table = READ_ONCE(rdma_nl_types[type].cb_table);
 
        int count = 0, ret;
 
        if (sg_cnt > pages_per_mr || prot_sg_cnt > pages_per_mr) {
-               pr_err("SG count too large: sg_cnt=%d, prot_sg_cnt=%d, pages_per_mr=%d\n",
+               pr_err("SG count too large: sg_cnt=%u, prot_sg_cnt=%u, pages_per_mr=%u\n",
                       sg_cnt, prot_sg_cnt, pages_per_mr);
                return -EINVAL;
        }
        ret = ib_map_mr_sg_pi(ctx->reg->mr, sg, sg_cnt, NULL, prot_sg,
                              prot_sg_cnt, NULL, SZ_4K);
        if (unlikely(ret)) {
-               pr_err("failed to map PI sg (%d)\n", sg_cnt + prot_sg_cnt);
+               pr_err("failed to map PI sg (%u)\n", sg_cnt + prot_sg_cnt);
                goto out_destroy_sig_mr;
        }
 
                                IB_MR_TYPE_MEM_REG,
                                max_num_sg, 0);
                if (ret) {
-                       pr_err("%s: failed to allocated %d MRs\n",
+                       pr_err("%s: failed to allocated %u MRs\n",
                                __func__, nr_mrs);
                        return ret;
                }
                ret = ib_mr_pool_init(qp, &qp->sig_mrs, nr_sig_mrs,
                                IB_MR_TYPE_INTEGRITY, max_num_sg, max_num_sg);
                if (ret) {
-                       pr_err("%s: failed to allocated %d SIG MRs\n",
+                       pr_err("%s: failed to allocated %u SIG MRs\n",
                                __func__, nr_sig_mrs);
                        goto out_free_rdma_mrs;
                }
 
        WARN_ONCE((qp_attr_mask & IB_QP_PORT &&
                   rdma_protocol_ib(real_qp->device, qp_attr->port_num) &&
                   !real_qp->qp_sec),
-                  "%s: QP security is not initialized for IB QP: %d\n",
+                  "%s: QP security is not initialized for IB QP: %u\n",
                   __func__, real_qp->qp_num);
 
        /* The port/pkey settings are maintained only for the real QP. Open
 
        if (ret)
                return ret;
 
-       return sysfs_emit(buf, "%d\n", attr.lmc);
+       return sysfs_emit(buf, "%u\n", attr.lmc);
 }
 
 static ssize_t sm_lid_show(struct ib_device *ibdev, u32 port_num,
        if (ret)
                return ret;
 
-       return sysfs_emit(buf, "%d\n", attr.sm_sl);
+       return sysfs_emit(buf, "%u\n", attr.sm_sl);
 }
 
 static ssize_t cap_mask_show(struct ib_device *ibdev, u32 port_num,
        if (ret)
                return ret;
 
-       return sysfs_emit(buf, "%d: %s\n", attr.phys_state,
+       return sysfs_emit(buf, "%u: %s\n", attr.phys_state,
                          phys_state_to_str(attr.phys_state));
 }
 
 
        switch (width) {
        case 4:
-               len = sysfs_emit(buf, "%u\n",
+               len = sysfs_emit(buf, "%d\n",
                                 (*data >> (4 - (offset % 8))) & 0xf);
                break;
        case 8:
 {
        struct ib_device *dev = rdma_device_to_ibdev(device);
 
-       return sysfs_emit(buf, "%d: %s\n", dev->node_type,
+       return sysfs_emit(buf, "%u: %s\n", dev->node_type,
                          node_type_string(dev->node_type));
 }
 static DEVICE_ATTR_RO(node_type);
 
        buf += IB_LRH_BYTES;
 
        if (header->lrh.link_version != 0) {
-               pr_warn("Invalid LRH.link_version %d\n",
+               pr_warn("Invalid LRH.link_version %u\n",
                        header->lrh.link_version);
                return -EINVAL;
        }
                buf += IB_GRH_BYTES;
 
                if (header->grh.ip_version != 6) {
-                       pr_warn("Invalid GRH.ip_version %d\n",
+                       pr_warn("Invalid GRH.ip_version %u\n",
                                header->grh.ip_version);
                        return -EINVAL;
                }
                break;
 
        default:
-               pr_warn("Invalid LRH.link_next_header %d\n",
+               pr_warn("Invalid LRH.link_next_header %u\n",
                        header->lrh.link_next_header);
                return -EINVAL;
        }
        }
 
        if (header->bth.transport_header_version != 0) {
-               pr_warn("Invalid BTH.transport_header_version %d\n",
+               pr_warn("Invalid BTH.transport_header_version %u\n",
                        header->bth.transport_header_version);
                return -EINVAL;
        }
 
                if (hmm_order + PAGE_SHIFT < page_shift) {
                        ret = -EINVAL;
                        ibdev_dbg(umem_odp->umem.ibdev,
-                                 "%s: un-expected hmm_order %d, page_shift %d\n",
+                                 "%s: un-expected hmm_order %u, page_shift %u\n",
                                  __func__, hmm_order, page_shift);
                        break;
                }
 
 
        if (ureq.qpn != 0 && ureq.qpn != 1) {
                dev_notice(&file->port->dev,
-                          "%s: invalid QPN %d specified\n", __func__,
+                          "%s: invalid QPN %u specified\n", __func__,
                           ureq.qpn);
                ret = -EINVAL;
                goto out;
        }
 
        if (ureq.qpn != 0 && ureq.qpn != 1) {
-               dev_notice(&file->port->dev, "%s: invalid QPN %d specified\n",
+               dev_notice(&file->port->dev, "%s: invalid QPN %u specified\n",
                           __func__, ureq.qpn);
                ret = -EINVAL;
                goto out;
 
                ib_spec += ((union ib_flow_spec *) ib_spec)->size;
        }
        if (cmd.flow_attr.size || (i != flow_attr->num_of_specs)) {
-               pr_warn("create flow failed, flow %d: %d bytes left from uverb cmd\n",
+               pr_warn("create flow failed, flow %d: %u bytes left from uverb cmd\n",
                        i, cmd.flow_attr.size);
                err = -EINVAL;
                goto err_free;
 
                count++;
        if (uapi_key_is_attr(key))
                count++;
-       WARN(count != 1, "Bad count %d key=%x", count, key);
+       WARN(count != 1, "Bad count %u key=%x", count, key);
 }
 
 static void uapi_finalize_disable(struct uverbs_api *uapi)
 
                netdev_speed = lksettings.base.speed;
        } else {
                netdev_speed = SPEED_1000;
-               pr_warn("%s speed is unknown, defaulting to %d\n", netdev->name,
+               pr_warn("%s speed is unknown, defaulting to %u\n", netdev->name,
                        netdev_speed);
        }