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

kernel-wide: replace USHORT_MAX, SHORT_MAX and SHORT_MIN with USHRT_MAX, SHRT_MAX and SHRT_MIN

- C99 knows about USHRT_MAX/SHRT_MAX/SHRT_MIN, not
USHORT_MAX/SHORT_MAX/SHORT_MIN.

- Make SHRT_MIN of type s16, not int, for consistency.

[akpm@linux-foundation.org: fix drivers/dma/timb_dma.c]
[akpm@linux-foundation.org: fix security/keys/keyring.c]
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Acked-by: WANG Cong <xiyou.wangcong@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

authored by

Alexey Dobriyan and committed by
Linus Torvalds 4be929be 940370fc

+41 -41
+1 -1
drivers/dma/timb_dma.c
··· 188 188 static int td_fill_desc(struct timb_dma_chan *td_chan, u8 *dma_desc, 189 189 struct scatterlist *sg, bool last) 190 190 { 191 - if (sg_dma_len(sg) > USHORT_MAX) { 191 + if (sg_dma_len(sg) > USHRT_MAX) { 192 192 dev_err(chan2dev(&td_chan->chan), "Too big sg element\n"); 193 193 return -EINVAL; 194 194 }
+1 -1
drivers/scsi/fcoe/fcoe.c
··· 688 688 } 689 689 690 690 if (!lport->vport) 691 - fc_host_max_npiv_vports(lport->host) = USHORT_MAX; 691 + fc_host_max_npiv_vports(lport->host) = USHRT_MAX; 692 692 693 693 snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE, 694 694 "%s v%s over %s", FCOE_NAME, FCOE_VERSION,
+1 -1
drivers/scsi/mpt2sas/mpt2sas_base.c
··· 3757 3757 if (ioc->config_cmds.status & MPT2_CMD_PENDING) { 3758 3758 ioc->config_cmds.status |= MPT2_CMD_RESET; 3759 3759 mpt2sas_base_free_smid(ioc, ioc->config_cmds.smid); 3760 - ioc->config_cmds.smid = USHORT_MAX; 3760 + ioc->config_cmds.smid = USHRT_MAX; 3761 3761 complete(&ioc->config_cmds.done); 3762 3762 } 3763 3763 break;
+1 -1
drivers/scsi/mpt2sas/mpt2sas_config.c
··· 258 258 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING 259 259 _config_display_some_debug(ioc, smid, "config_done", mpi_reply); 260 260 #endif 261 - ioc->config_cmds.smid = USHORT_MAX; 261 + ioc->config_cmds.smid = USHRT_MAX; 262 262 complete(&ioc->config_cmds.done); 263 263 return 1; 264 264 }
+1 -1
drivers/vhost/vhost.c
··· 806 806 count = indirect->len / sizeof desc; 807 807 /* Buffers are chained via a 16 bit next field, so 808 808 * we can have at most 2^16 of these. */ 809 - if (count > USHORT_MAX + 1) { 809 + if (count > USHRT_MAX + 1) { 810 810 vq_err(vq, "Indirect buffer length too big: %d\n", 811 811 indirect->len); 812 812 return -E2BIG;
+2 -2
fs/nfs/super.c
··· 1060 1060 goto out_nomem; 1061 1061 rc = strict_strtoul(string, 10, &option); 1062 1062 kfree(string); 1063 - if (rc != 0 || option > USHORT_MAX) 1063 + if (rc != 0 || option > USHRT_MAX) 1064 1064 goto out_invalid_value; 1065 1065 mnt->nfs_server.port = option; 1066 1066 break; ··· 1181 1181 goto out_nomem; 1182 1182 rc = strict_strtoul(string, 10, &option); 1183 1183 kfree(string); 1184 - if (rc != 0 || option > USHORT_MAX) 1184 + if (rc != 0 || option > USHRT_MAX) 1185 1185 goto out_invalid_value; 1186 1186 mnt->mount_server.port = option; 1187 1187 break;
+2 -2
fs/nfsd/nfsctl.c
··· 998 998 if (sscanf(buf, "%15s %4u", transport, &port) != 2) 999 999 return -EINVAL; 1000 1000 1001 - if (port < 1 || port > USHORT_MAX) 1001 + if (port < 1 || port > USHRT_MAX) 1002 1002 return -EINVAL; 1003 1003 1004 1004 err = nfsd_create_serv(); ··· 1040 1040 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2) 1041 1041 return -EINVAL; 1042 1042 1043 - if (port < 1 || port > USHORT_MAX || nfsd_serv == NULL) 1043 + if (port < 1 || port > USHRT_MAX || nfsd_serv == NULL) 1044 1044 return -EINVAL; 1045 1045 1046 1046 xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port);
+2 -2
fs/ocfs2/blockcheck.c
··· 403 403 * No ecc'd ocfs2 structure is larger than 4K, so ecc will be no 404 404 * larger than 16 bits. 405 405 */ 406 - BUG_ON(ecc > USHORT_MAX); 406 + BUG_ON(ecc > USHRT_MAX); 407 407 408 408 bc->bc_crc32e = cpu_to_le32(crc); 409 409 bc->bc_ecc = cpu_to_le16((u16)ecc); ··· 508 508 * No ecc'd ocfs2 structure is larger than 4K, so ecc will be no 509 509 * larger than 16 bits. 510 510 */ 511 - BUG_ON(ecc > USHORT_MAX); 511 + BUG_ON(ecc > USHRT_MAX); 512 512 513 513 bc->bc_crc32e = cpu_to_le32(crc); 514 514 bc->bc_ecc = cpu_to_le16((u16)ecc);
+3 -3
include/linux/kernel.h
··· 24 24 extern const char linux_banner[]; 25 25 extern const char linux_proc_banner[]; 26 26 27 - #define USHORT_MAX ((u16)(~0U)) 28 - #define SHORT_MAX ((s16)(USHORT_MAX>>1)) 29 - #define SHORT_MIN (-SHORT_MAX - 1) 27 + #define USHRT_MAX ((u16)(~0U)) 28 + #define SHRT_MAX ((s16)(USHRT_MAX>>1)) 29 + #define SHRT_MIN ((s16)(-SHRT_MAX - 1)) 30 30 #define INT_MAX ((int)(~0U>>1)) 31 31 #define INT_MIN (-INT_MAX - 1) 32 32 #define UINT_MAX (~0U)
+1 -1
include/linux/sched.h
··· 384 384 * 1-3 now and depends on arch. We use "5" as safe margin, here. 385 385 */ 386 386 #define MAPCOUNT_ELF_CORE_MARGIN (5) 387 - #define DEFAULT_MAX_MAP_COUNT (USHORT_MAX - MAPCOUNT_ELF_CORE_MARGIN) 387 + #define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN) 388 388 389 389 extern int sysctl_max_map_count; 390 390
+3 -3
include/net/ip.h
··· 358 358 IP_DEFRAG_LOCAL_DELIVER, 359 359 IP_DEFRAG_CALL_RA_CHAIN, 360 360 IP_DEFRAG_CONNTRACK_IN, 361 - __IP_DEFRAG_CONNTRACK_IN_END = IP_DEFRAG_CONNTRACK_IN + USHORT_MAX, 361 + __IP_DEFRAG_CONNTRACK_IN_END = IP_DEFRAG_CONNTRACK_IN + USHRT_MAX, 362 362 IP_DEFRAG_CONNTRACK_OUT, 363 - __IP_DEFRAG_CONNTRACK_OUT_END = IP_DEFRAG_CONNTRACK_OUT + USHORT_MAX, 363 + __IP_DEFRAG_CONNTRACK_OUT_END = IP_DEFRAG_CONNTRACK_OUT + USHRT_MAX, 364 364 IP_DEFRAG_CONNTRACK_BRIDGE_IN, 365 - __IP_DEFRAG_CONNTRACK_BRIDGE_IN = IP_DEFRAG_CONNTRACK_BRIDGE_IN + USHORT_MAX, 365 + __IP_DEFRAG_CONNTRACK_BRIDGE_IN = IP_DEFRAG_CONNTRACK_BRIDGE_IN + USHRT_MAX, 366 366 IP_DEFRAG_VS_IN, 367 367 IP_DEFRAG_VS_OUT, 368 368 IP_DEFRAG_VS_FWD
+3 -3
include/net/ipv6.h
··· 354 354 enum ip6_defrag_users { 355 355 IP6_DEFRAG_LOCAL_DELIVER, 356 356 IP6_DEFRAG_CONNTRACK_IN, 357 - __IP6_DEFRAG_CONNTRACK_IN = IP6_DEFRAG_CONNTRACK_IN + USHORT_MAX, 357 + __IP6_DEFRAG_CONNTRACK_IN = IP6_DEFRAG_CONNTRACK_IN + USHRT_MAX, 358 358 IP6_DEFRAG_CONNTRACK_OUT, 359 - __IP6_DEFRAG_CONNTRACK_OUT = IP6_DEFRAG_CONNTRACK_OUT + USHORT_MAX, 359 + __IP6_DEFRAG_CONNTRACK_OUT = IP6_DEFRAG_CONNTRACK_OUT + USHRT_MAX, 360 360 IP6_DEFRAG_CONNTRACK_BRIDGE_IN, 361 - __IP6_DEFRAG_CONNTRACK_BRIDGE_IN = IP6_DEFRAG_CONNTRACK_BRIDGE_IN + USHORT_MAX, 361 + __IP6_DEFRAG_CONNTRACK_BRIDGE_IN = IP6_DEFRAG_CONNTRACK_BRIDGE_IN + USHRT_MAX, 362 362 }; 363 363 364 364 struct ip6_create_arg {
+6 -6
ipc/msg.c
··· 345 345 out.msg_rtime = in->msg_rtime; 346 346 out.msg_ctime = in->msg_ctime; 347 347 348 - if (in->msg_cbytes > USHORT_MAX) 349 - out.msg_cbytes = USHORT_MAX; 348 + if (in->msg_cbytes > USHRT_MAX) 349 + out.msg_cbytes = USHRT_MAX; 350 350 else 351 351 out.msg_cbytes = in->msg_cbytes; 352 352 out.msg_lcbytes = in->msg_cbytes; 353 353 354 - if (in->msg_qnum > USHORT_MAX) 355 - out.msg_qnum = USHORT_MAX; 354 + if (in->msg_qnum > USHRT_MAX) 355 + out.msg_qnum = USHRT_MAX; 356 356 else 357 357 out.msg_qnum = in->msg_qnum; 358 358 359 - if (in->msg_qbytes > USHORT_MAX) 360 - out.msg_qbytes = USHORT_MAX; 359 + if (in->msg_qbytes > USHRT_MAX) 360 + out.msg_qbytes = USHRT_MAX; 361 361 else 362 362 out.msg_qbytes = in->msg_qbytes; 363 363 out.msg_lqbytes = in->msg_qbytes;
+2 -2
ipc/util.c
··· 124 124 ids->seq = 0; 125 125 { 126 126 int seq_limit = INT_MAX/SEQ_MULTIPLIER; 127 - if (seq_limit > USHORT_MAX) 128 - ids->seq_max = USHORT_MAX; 127 + if (seq_limit > USHRT_MAX) 128 + ids->seq_max = USHRT_MAX; 129 129 else 130 130 ids->seq_max = seq_limit; 131 131 }
+1 -1
lib/vsprintf.c
··· 1980 1980 { 1981 1981 char *s = (char *)va_arg(args, char *); 1982 1982 if (field_width == -1) 1983 - field_width = SHORT_MAX; 1983 + field_width = SHRT_MAX; 1984 1984 /* first, skip leading white space in buffer */ 1985 1985 str = skip_spaces(str); 1986 1986
+1 -1
net/9p/protocol.c
··· 394 394 const char *sptr = va_arg(ap, const char *); 395 395 int16_t len = 0; 396 396 if (sptr) 397 - len = MIN(strlen(sptr), USHORT_MAX); 397 + len = MIN(strlen(sptr), USHRT_MAX); 398 398 399 399 errcode = p9pdu_writef(pdu, proto_version, 400 400 "w", len);
+1 -1
net/dccp/options.c
··· 296 296 { 297 297 if (likely(ndp <= 0xFF)) 298 298 return 1; 299 - return likely(ndp <= USHORT_MAX) ? 2 : (ndp <= UINT_MAX ? 4 : 6); 299 + return likely(ndp <= USHRT_MAX) ? 2 : (ndp <= UINT_MAX ? 4 : 6); 300 300 } 301 301 302 302 int dccp_insert_option(struct sock *sk, struct sk_buff *skb,
+4 -4
net/ipv4/udp.c
··· 1686 1686 return -ENOPROTOOPT; 1687 1687 if (val != 0 && val < 8) /* Illegal coverage: use default (8) */ 1688 1688 val = 8; 1689 - else if (val > USHORT_MAX) 1690 - val = USHORT_MAX; 1689 + else if (val > USHRT_MAX) 1690 + val = USHRT_MAX; 1691 1691 up->pcslen = val; 1692 1692 up->pcflag |= UDPLITE_SEND_CC; 1693 1693 break; ··· 1700 1700 return -ENOPROTOOPT; 1701 1701 if (val != 0 && val < 8) /* Avoid silly minimal values. */ 1702 1702 val = 8; 1703 - else if (val > USHORT_MAX) 1704 - val = USHORT_MAX; 1703 + else if (val > USHRT_MAX) 1704 + val = USHRT_MAX; 1705 1705 up->pcrlen = val; 1706 1706 up->pcflag |= UDPLITE_RECV_CC; 1707 1707 break;
+1 -1
net/mac80211/sta_info.c
··· 259 259 skb_queue_head_init(&sta->tx_filtered); 260 260 261 261 for (i = 0; i < NUM_RX_DATA_QUEUES; i++) 262 - sta->last_seq_ctrl[i] = cpu_to_le16(USHORT_MAX); 262 + sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX); 263 263 264 264 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 265 265 printk(KERN_DEBUG "%s: Allocated STA %pM\n",
+1 -1
net/sunrpc/rpcb_clnt.c
··· 783 783 port = ntohl(*p); 784 784 dprintk("RPC: %5u PMAP_%s result: %lu\n", task->tk_pid, 785 785 task->tk_msg.rpc_proc->p_name, port); 786 - if (unlikely(port > USHORT_MAX)) 786 + if (unlikely(port > USHRT_MAX)) 787 787 return -EIO; 788 788 789 789 rpcb->r_port = port;
+3 -3
security/keys/keyring.c
··· 669 669 struct keyring_list *klist = 670 670 container_of(rcu, struct keyring_list, rcu); 671 671 672 - if (klist->delkey != USHORT_MAX) 672 + if (klist->delkey != USHRT_MAX) 673 673 key_put(klist->keys[klist->delkey]); 674 674 kfree(klist); 675 675 } ··· 746 746 max += klist->maxkeys; 747 747 748 748 ret = -ENFILE; 749 - if (max > USHORT_MAX - 1) 749 + if (max > USHRT_MAX - 1) 750 750 goto error_quota; 751 751 size = sizeof(*klist) + sizeof(struct key *) * max; 752 752 if (size > PAGE_SIZE) ··· 763 763 sizeof(struct key *) * klist->nkeys); 764 764 nklist->delkey = klist->nkeys; 765 765 nklist->nkeys = klist->nkeys + 1; 766 - klist->delkey = USHORT_MAX; 766 + klist->delkey = USHRT_MAX; 767 767 } else { 768 768 nklist->nkeys = 1; 769 769 nklist->delkey = 0;