lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  linux-cve-announce  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-ID: <202204270907.nUUrw3dS-lkp@intel.com>
Date:   Wed, 27 Apr 2022 09:43:22 +0800
From:   kernel test robot <lkp@...el.com>
To:     Erin MacNeil <lnx.erin@...il.com>, netdev@...r.kernel.org
Cc:     kbuild-all@...ts.01.org, Erin MacNeil <lnx.erin@...il.com>
Subject: Re: [PATCH net-next] net: Add SO_RCVMARK socket option to provide
 SO_MARK with recvmsg().

Hi Erin,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on net-next/master]

url:    https://github.com/intel-lab-lkp/linux/commits/Erin-MacNeil/net-Add-SO_RCVMARK-socket-option-to-provide-SO_MARK-with-recvmsg/20220427-014257
base:   https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git 561215482cc69d1c758944d4463b3d5d96d37bd1
config: alpha-defconfig (https://download.01.org/0day-ci/archive/20220427/202204270907.nUUrw3dS-lkp@intel.com/config)
compiler: alpha-linux-gcc (GCC) 11.3.0
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/intel-lab-lkp/linux/commit/ba0c57c49e3f18b23fe626dd2e603cf4ed91ebf7
        git remote add linux-review https://github.com/intel-lab-lkp/linux
        git fetch --no-tags linux-review Erin-MacNeil/net-Add-SO_RCVMARK-socket-option-to-provide-SO_MARK-with-recvmsg/20220427-014257
        git checkout ba0c57c49e3f18b23fe626dd2e603cf4ed91ebf7
        # save the config file
        mkdir build_dir && cp config build_dir/.config
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.3.0 make.cross W=1 O=build_dir ARCH=alpha SHELL=/bin/bash

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@...el.com>

All errors (new ones prefixed by >>):

   net/core/sock.c: In function 'sock_setsockopt':
>> net/core/sock.c:1314:14: error: 'SO_RCVMARK' undeclared (first use in this function); did you mean 'SOCK_RCVMARK'?
    1314 |         case SO_RCVMARK:
         |              ^~~~~~~~~~
         |              SOCK_RCVMARK
   net/core/sock.c:1314:14: note: each undeclared identifier is reported only once for each function it appears in
   net/core/sock.c: In function 'sock_getsockopt':
   net/core/sock.c:1743:14: error: 'SO_RCVMARK' undeclared (first use in this function); did you mean 'SOCK_RCVMARK'?
    1743 |         case SO_RCVMARK:
         |              ^~~~~~~~~~
         |              SOCK_RCVMARK


vim +1314 net/core/sock.c

  1031	
  1032	/*
  1033	 *	This is meant for all protocols to use and covers goings on
  1034	 *	at the socket level. Everything here is generic.
  1035	 */
  1036	
  1037	int sock_setsockopt(struct socket *sock, int level, int optname,
  1038			    sockptr_t optval, unsigned int optlen)
  1039	{
  1040		struct so_timestamping timestamping;
  1041		struct sock_txtime sk_txtime;
  1042		struct sock *sk = sock->sk;
  1043		int val;
  1044		int valbool;
  1045		struct linger ling;
  1046		int ret = 0;
  1047	
  1048		/*
  1049		 *	Options without arguments
  1050		 */
  1051	
  1052		if (optname == SO_BINDTODEVICE)
  1053			return sock_setbindtodevice(sk, optval, optlen);
  1054	
  1055		if (optlen < sizeof(int))
  1056			return -EINVAL;
  1057	
  1058		if (copy_from_sockptr(&val, optval, sizeof(val)))
  1059			return -EFAULT;
  1060	
  1061		valbool = val ? 1 : 0;
  1062	
  1063		lock_sock(sk);
  1064	
  1065		switch (optname) {
  1066		case SO_DEBUG:
  1067			if (val && !capable(CAP_NET_ADMIN))
  1068				ret = -EACCES;
  1069			else
  1070				sock_valbool_flag(sk, SOCK_DBG, valbool);
  1071			break;
  1072		case SO_REUSEADDR:
  1073			sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
  1074			break;
  1075		case SO_REUSEPORT:
  1076			sk->sk_reuseport = valbool;
  1077			break;
  1078		case SO_TYPE:
  1079		case SO_PROTOCOL:
  1080		case SO_DOMAIN:
  1081		case SO_ERROR:
  1082			ret = -ENOPROTOOPT;
  1083			break;
  1084		case SO_DONTROUTE:
  1085			sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
  1086			sk_dst_reset(sk);
  1087			break;
  1088		case SO_BROADCAST:
  1089			sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
  1090			break;
  1091		case SO_SNDBUF:
  1092			/* Don't error on this BSD doesn't and if you think
  1093			 * about it this is right. Otherwise apps have to
  1094			 * play 'guess the biggest size' games. RCVBUF/SNDBUF
  1095			 * are treated in BSD as hints
  1096			 */
  1097			val = min_t(u32, val, sysctl_wmem_max);
  1098	set_sndbuf:
  1099			/* Ensure val * 2 fits into an int, to prevent max_t()
  1100			 * from treating it as a negative value.
  1101			 */
  1102			val = min_t(int, val, INT_MAX / 2);
  1103			sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
  1104			WRITE_ONCE(sk->sk_sndbuf,
  1105				   max_t(int, val * 2, SOCK_MIN_SNDBUF));
  1106			/* Wake up sending tasks if we upped the value. */
  1107			sk->sk_write_space(sk);
  1108			break;
  1109	
  1110		case SO_SNDBUFFORCE:
  1111			if (!capable(CAP_NET_ADMIN)) {
  1112				ret = -EPERM;
  1113				break;
  1114			}
  1115	
  1116			/* No negative values (to prevent underflow, as val will be
  1117			 * multiplied by 2).
  1118			 */
  1119			if (val < 0)
  1120				val = 0;
  1121			goto set_sndbuf;
  1122	
  1123		case SO_RCVBUF:
  1124			/* Don't error on this BSD doesn't and if you think
  1125			 * about it this is right. Otherwise apps have to
  1126			 * play 'guess the biggest size' games. RCVBUF/SNDBUF
  1127			 * are treated in BSD as hints
  1128			 */
  1129			__sock_set_rcvbuf(sk, min_t(u32, val, sysctl_rmem_max));
  1130			break;
  1131	
  1132		case SO_RCVBUFFORCE:
  1133			if (!capable(CAP_NET_ADMIN)) {
  1134				ret = -EPERM;
  1135				break;
  1136			}
  1137	
  1138			/* No negative values (to prevent underflow, as val will be
  1139			 * multiplied by 2).
  1140			 */
  1141			__sock_set_rcvbuf(sk, max(val, 0));
  1142			break;
  1143	
  1144		case SO_KEEPALIVE:
  1145			if (sk->sk_prot->keepalive)
  1146				sk->sk_prot->keepalive(sk, valbool);
  1147			sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
  1148			break;
  1149	
  1150		case SO_OOBINLINE:
  1151			sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
  1152			break;
  1153	
  1154		case SO_NO_CHECK:
  1155			sk->sk_no_check_tx = valbool;
  1156			break;
  1157	
  1158		case SO_PRIORITY:
  1159			if ((val >= 0 && val <= 6) ||
  1160			    ns_capable(sock_net(sk)->user_ns, CAP_NET_RAW) ||
  1161			    ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
  1162				sk->sk_priority = val;
  1163			else
  1164				ret = -EPERM;
  1165			break;
  1166	
  1167		case SO_LINGER:
  1168			if (optlen < sizeof(ling)) {
  1169				ret = -EINVAL;	/* 1003.1g */
  1170				break;
  1171			}
  1172			if (copy_from_sockptr(&ling, optval, sizeof(ling))) {
  1173				ret = -EFAULT;
  1174				break;
  1175			}
  1176			if (!ling.l_onoff)
  1177				sock_reset_flag(sk, SOCK_LINGER);
  1178			else {
  1179	#if (BITS_PER_LONG == 32)
  1180				if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
  1181					sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
  1182				else
  1183	#endif
  1184					sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
  1185				sock_set_flag(sk, SOCK_LINGER);
  1186			}
  1187			break;
  1188	
  1189		case SO_BSDCOMPAT:
  1190			break;
  1191	
  1192		case SO_PASSCRED:
  1193			if (valbool)
  1194				set_bit(SOCK_PASSCRED, &sock->flags);
  1195			else
  1196				clear_bit(SOCK_PASSCRED, &sock->flags);
  1197			break;
  1198	
  1199		case SO_TIMESTAMP_OLD:
  1200		case SO_TIMESTAMP_NEW:
  1201		case SO_TIMESTAMPNS_OLD:
  1202		case SO_TIMESTAMPNS_NEW:
  1203			sock_set_timestamp(sk, optname, valbool);
  1204			break;
  1205	
  1206		case SO_TIMESTAMPING_NEW:
  1207		case SO_TIMESTAMPING_OLD:
  1208			if (optlen == sizeof(timestamping)) {
  1209				if (copy_from_sockptr(&timestamping, optval,
  1210						      sizeof(timestamping))) {
  1211					ret = -EFAULT;
  1212					break;
  1213				}
  1214			} else {
  1215				memset(&timestamping, 0, sizeof(timestamping));
  1216				timestamping.flags = val;
  1217			}
  1218			ret = sock_set_timestamping(sk, optname, timestamping);
  1219			break;
  1220	
  1221		case SO_RCVLOWAT:
  1222			if (val < 0)
  1223				val = INT_MAX;
  1224			if (sock->ops->set_rcvlowat)
  1225				ret = sock->ops->set_rcvlowat(sk, val);
  1226			else
  1227				WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
  1228			break;
  1229	
  1230		case SO_RCVTIMEO_OLD:
  1231		case SO_RCVTIMEO_NEW:
  1232			ret = sock_set_timeout(&sk->sk_rcvtimeo, optval,
  1233					       optlen, optname == SO_RCVTIMEO_OLD);
  1234			break;
  1235	
  1236		case SO_SNDTIMEO_OLD:
  1237		case SO_SNDTIMEO_NEW:
  1238			ret = sock_set_timeout(&sk->sk_sndtimeo, optval,
  1239					       optlen, optname == SO_SNDTIMEO_OLD);
  1240			break;
  1241	
  1242		case SO_ATTACH_FILTER: {
  1243			struct sock_fprog fprog;
  1244	
  1245			ret = copy_bpf_fprog_from_user(&fprog, optval, optlen);
  1246			if (!ret)
  1247				ret = sk_attach_filter(&fprog, sk);
  1248			break;
  1249		}
  1250		case SO_ATTACH_BPF:
  1251			ret = -EINVAL;
  1252			if (optlen == sizeof(u32)) {
  1253				u32 ufd;
  1254	
  1255				ret = -EFAULT;
  1256				if (copy_from_sockptr(&ufd, optval, sizeof(ufd)))
  1257					break;
  1258	
  1259				ret = sk_attach_bpf(ufd, sk);
  1260			}
  1261			break;
  1262	
  1263		case SO_ATTACH_REUSEPORT_CBPF: {
  1264			struct sock_fprog fprog;
  1265	
  1266			ret = copy_bpf_fprog_from_user(&fprog, optval, optlen);
  1267			if (!ret)
  1268				ret = sk_reuseport_attach_filter(&fprog, sk);
  1269			break;
  1270		}
  1271		case SO_ATTACH_REUSEPORT_EBPF:
  1272			ret = -EINVAL;
  1273			if (optlen == sizeof(u32)) {
  1274				u32 ufd;
  1275	
  1276				ret = -EFAULT;
  1277				if (copy_from_sockptr(&ufd, optval, sizeof(ufd)))
  1278					break;
  1279	
  1280				ret = sk_reuseport_attach_bpf(ufd, sk);
  1281			}
  1282			break;
  1283	
  1284		case SO_DETACH_REUSEPORT_BPF:
  1285			ret = reuseport_detach_prog(sk);
  1286			break;
  1287	
  1288		case SO_DETACH_FILTER:
  1289			ret = sk_detach_filter(sk);
  1290			break;
  1291	
  1292		case SO_LOCK_FILTER:
  1293			if (sock_flag(sk, SOCK_FILTER_LOCKED) && !valbool)
  1294				ret = -EPERM;
  1295			else
  1296				sock_valbool_flag(sk, SOCK_FILTER_LOCKED, valbool);
  1297			break;
  1298	
  1299		case SO_PASSSEC:
  1300			if (valbool)
  1301				set_bit(SOCK_PASSSEC, &sock->flags);
  1302			else
  1303				clear_bit(SOCK_PASSSEC, &sock->flags);
  1304			break;
  1305		case SO_MARK:
  1306			if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_RAW) &&
  1307			    !ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
  1308				ret = -EPERM;
  1309				break;
  1310			}
  1311	
  1312			__sock_set_mark(sk, val);
  1313			break;
> 1314		case SO_RCVMARK:
  1315			sock_valbool_flag(sk, SOCK_RCVMARK, valbool);
  1316			break;
  1317	
  1318		case SO_RXQ_OVFL:
  1319			sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
  1320			break;
  1321	
  1322		case SO_WIFI_STATUS:
  1323			sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
  1324			break;
  1325	
  1326		case SO_PEEK_OFF:
  1327			if (sock->ops->set_peek_off)
  1328				ret = sock->ops->set_peek_off(sk, val);
  1329			else
  1330				ret = -EOPNOTSUPP;
  1331			break;
  1332	
  1333		case SO_NOFCS:
  1334			sock_valbool_flag(sk, SOCK_NOFCS, valbool);
  1335			break;
  1336	
  1337		case SO_SELECT_ERR_QUEUE:
  1338			sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
  1339			break;
  1340	

-- 
0-DAY CI Kernel Test Service
https://01.org/lkp

Powered by blists - more mailing lists

Powered by Openwall GNU/*/Linux Powered by OpenVZ