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  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]
Date:   Mon, 4 Jan 2021 01:03:26 +0800
From:   kernel test robot <lkp@...el.com>
To:     Jouni Seppänen <jks@....fi>,
        Oliver Neukum <oliver@...kum.org>, linux-usb@...r.kernel.org
Cc:     kbuild-all@...ts.01.org, clang-built-linux@...glegroups.com,
        jks@....fi, Bjørn Mork <bjorn@...k.no>,
        Jakub Kicinski <kuba@...nel.org>,
        Enrico Mioso <mrkiko.rs@...il.com>, netdev@...r.kernel.org,
        linux-kernel@...r.kernel.org
Subject: Re: [PATCH net,stable] net: cdc_ncm: correct overhead in
 delayed_ndp_size

Hi "Jouni,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on linus/master]
[also build test WARNING on v5.11-rc1 next-20201223]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Jouni-Sepp-nen/net-cdc_ncm-correct-overhead-in-delayed_ndp_size/20210103-224538
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 3516bd729358a2a9b090c1905bd2a3fa926e24c6
config: x86_64-randconfig-a003-20210103 (attached as .config)
compiler: clang version 12.0.0 (https://github.com/llvm/llvm-project 7af6a134508cd1c7f75c6e3441ce436f220f30a4)
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
        # install x86_64 cross compiling tool for clang build
        # apt-get install binutils-x86-64-linux-gnu
        # https://github.com/0day-ci/linux/commit/3d8cc665ef1cf4705135a5a96893a6fdc6dcd398
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Jouni-Sepp-nen/net-cdc_ncm-correct-overhead-in-delayed_ndp_size/20210103-224538
        git checkout 3d8cc665ef1cf4705135a5a96893a6fdc6dcd398
        # save the attached .config to linux build tree
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64 

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

All warnings (new ones prefixed by >>):

>> drivers/net/usb/cdc_ncm.c:1203:4: warning: comparison of distinct pointer types ('typeof (ctx->tx_ndp_modulus) *' (aka 'unsigned short *') and 'typeof (ctx->tx_modulus + ctx->tx_remainder) *' (aka 'int *')) [-Wcompare-distinct-pointer-types]
                           max(ctx->tx_ndp_modulus,
                           ^~~~~~~~~~~~~~~~~~~~~~~~
   include/linux/minmax.h:58:19: note: expanded from macro 'max'
   #define max(x, y)       __careful_cmp(x, y, >)
                           ^~~~~~~~~~~~~~~~~~~~~~
   include/linux/minmax.h:42:24: note: expanded from macro '__careful_cmp'
           __builtin_choose_expr(__safe_cmp(x, y), \
                                 ^~~~~~~~~~~~~~~~
   include/linux/minmax.h:32:4: note: expanded from macro '__safe_cmp'
                   (__typecheck(x, y) && __no_side_effects(x, y))
                    ^~~~~~~~~~~~~~~~~
   include/linux/minmax.h:18:28: note: expanded from macro '__typecheck'
           (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1)))
                      ~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~
   1 warning generated.


vim +1203 drivers/net/usb/cdc_ncm.c

  1179	
  1180	struct sk_buff *
  1181	cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign)
  1182	{
  1183		struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
  1184		union {
  1185			struct usb_cdc_ncm_nth16 *nth16;
  1186			struct usb_cdc_ncm_nth32 *nth32;
  1187		} nth;
  1188		union {
  1189			struct usb_cdc_ncm_ndp16 *ndp16;
  1190			struct usb_cdc_ncm_ndp32 *ndp32;
  1191		} ndp;
  1192		struct sk_buff *skb_out;
  1193		u16 n = 0, index, ndplen;
  1194		u8 ready2send = 0;
  1195		u32 delayed_ndp_size;
  1196		size_t padding_count;
  1197	
  1198		/* When our NDP gets written in cdc_ncm_ndp(), then skb_out->len gets updated
  1199		 * accordingly. Otherwise, we should check here.
  1200		 */
  1201		if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END)
  1202			delayed_ndp_size = ctx->max_ndp_size +
> 1203				max(ctx->tx_ndp_modulus,
  1204				    ctx->tx_modulus + ctx->tx_remainder) - 1;
  1205		else
  1206			delayed_ndp_size = 0;
  1207	
  1208		/* if there is a remaining skb, it gets priority */
  1209		if (skb != NULL) {
  1210			swap(skb, ctx->tx_rem_skb);
  1211			swap(sign, ctx->tx_rem_sign);
  1212		} else {
  1213			ready2send = 1;
  1214		}
  1215	
  1216		/* check if we are resuming an OUT skb */
  1217		skb_out = ctx->tx_curr_skb;
  1218	
  1219		/* allocate a new OUT skb */
  1220		if (!skb_out) {
  1221			if (ctx->tx_low_mem_val == 0) {
  1222				ctx->tx_curr_size = ctx->tx_max;
  1223				skb_out = alloc_skb(ctx->tx_curr_size, GFP_ATOMIC);
  1224				/* If the memory allocation fails we will wait longer
  1225				 * each time before attempting another full size
  1226				 * allocation again to not overload the system
  1227				 * further.
  1228				 */
  1229				if (skb_out == NULL) {
  1230					ctx->tx_low_mem_max_cnt = min(ctx->tx_low_mem_max_cnt + 1,
  1231								      (unsigned)CDC_NCM_LOW_MEM_MAX_CNT);
  1232					ctx->tx_low_mem_val = ctx->tx_low_mem_max_cnt;
  1233				}
  1234			}
  1235			if (skb_out == NULL) {
  1236				/* See if a very small allocation is possible.
  1237				 * We will send this packet immediately and hope
  1238				 * that there is more memory available later.
  1239				 */
  1240				if (skb)
  1241					ctx->tx_curr_size = max(skb->len,
  1242						(u32)USB_CDC_NCM_NTB_MIN_OUT_SIZE);
  1243				else
  1244					ctx->tx_curr_size = USB_CDC_NCM_NTB_MIN_OUT_SIZE;
  1245				skb_out = alloc_skb(ctx->tx_curr_size, GFP_ATOMIC);
  1246	
  1247				/* No allocation possible so we will abort */
  1248				if (skb_out == NULL) {
  1249					if (skb != NULL) {
  1250						dev_kfree_skb_any(skb);
  1251						dev->net->stats.tx_dropped++;
  1252					}
  1253					goto exit_no_skb;
  1254				}
  1255				ctx->tx_low_mem_val--;
  1256			}
  1257			if (ctx->is_ndp16) {
  1258				/* fill out the initial 16-bit NTB header */
  1259				nth.nth16 = skb_put_zero(skb_out, sizeof(struct usb_cdc_ncm_nth16));
  1260				nth.nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN);
  1261				nth.nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16));
  1262				nth.nth16->wSequence = cpu_to_le16(ctx->tx_seq++);
  1263			} else {
  1264				/* fill out the initial 32-bit NTB header */
  1265				nth.nth32 = skb_put_zero(skb_out, sizeof(struct usb_cdc_ncm_nth32));
  1266				nth.nth32->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH32_SIGN);
  1267				nth.nth32->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth32));
  1268				nth.nth32->wSequence = cpu_to_le16(ctx->tx_seq++);
  1269			}
  1270	
  1271			/* count total number of frames in this NTB */
  1272			ctx->tx_curr_frame_num = 0;
  1273	
  1274			/* recent payload counter for this skb_out */
  1275			ctx->tx_curr_frame_payload = 0;
  1276		}
  1277	
  1278		for (n = ctx->tx_curr_frame_num; n < ctx->tx_max_datagrams; n++) {
  1279			/* send any remaining skb first */
  1280			if (skb == NULL) {
  1281				skb = ctx->tx_rem_skb;
  1282				sign = ctx->tx_rem_sign;
  1283				ctx->tx_rem_skb = NULL;
  1284	
  1285				/* check for end of skb */
  1286				if (skb == NULL)
  1287					break;
  1288			}
  1289	
  1290			/* get the appropriate NDP for this skb */
  1291			if (ctx->is_ndp16)
  1292				ndp.ndp16 = cdc_ncm_ndp16(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder);
  1293			else
  1294				ndp.ndp32 = cdc_ncm_ndp32(ctx, skb_out, sign, skb->len + ctx->tx_modulus + ctx->tx_remainder);
  1295	
  1296			/* align beginning of next frame */
  1297			cdc_ncm_align_tail(skb_out,  ctx->tx_modulus, ctx->tx_remainder, ctx->tx_curr_size);
  1298	
  1299			/* check if we had enough room left for both NDP and frame */
  1300			if ((ctx->is_ndp16 && !ndp.ndp16) || (!ctx->is_ndp16 && !ndp.ndp32) ||
  1301			    skb_out->len + skb->len + delayed_ndp_size > ctx->tx_curr_size) {
  1302				if (n == 0) {
  1303					/* won't fit, MTU problem? */
  1304					dev_kfree_skb_any(skb);
  1305					skb = NULL;
  1306					dev->net->stats.tx_dropped++;
  1307				} else {
  1308					/* no room for skb - store for later */
  1309					if (ctx->tx_rem_skb != NULL) {
  1310						dev_kfree_skb_any(ctx->tx_rem_skb);
  1311						dev->net->stats.tx_dropped++;
  1312					}
  1313					ctx->tx_rem_skb = skb;
  1314					ctx->tx_rem_sign = sign;
  1315					skb = NULL;
  1316					ready2send = 1;
  1317					ctx->tx_reason_ntb_full++;	/* count reason for transmitting */
  1318				}
  1319				break;
  1320			}
  1321	
  1322			/* calculate frame number within this NDP */
  1323			if (ctx->is_ndp16) {
  1324				ndplen = le16_to_cpu(ndp.ndp16->wLength);
  1325				index = (ndplen - sizeof(struct usb_cdc_ncm_ndp16)) / sizeof(struct usb_cdc_ncm_dpe16) - 1;
  1326	
  1327				/* OK, add this skb */
  1328				ndp.ndp16->dpe16[index].wDatagramLength = cpu_to_le16(skb->len);
  1329				ndp.ndp16->dpe16[index].wDatagramIndex = cpu_to_le16(skb_out->len);
  1330				ndp.ndp16->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe16));
  1331			} else {
  1332				ndplen = le16_to_cpu(ndp.ndp32->wLength);
  1333				index = (ndplen - sizeof(struct usb_cdc_ncm_ndp32)) / sizeof(struct usb_cdc_ncm_dpe32) - 1;
  1334	
  1335				ndp.ndp32->dpe32[index].dwDatagramLength = cpu_to_le32(skb->len);
  1336				ndp.ndp32->dpe32[index].dwDatagramIndex = cpu_to_le32(skb_out->len);
  1337				ndp.ndp32->wLength = cpu_to_le16(ndplen + sizeof(struct usb_cdc_ncm_dpe32));
  1338			}
  1339			skb_put_data(skb_out, skb->data, skb->len);
  1340			ctx->tx_curr_frame_payload += skb->len;	/* count real tx payload data */
  1341			dev_kfree_skb_any(skb);
  1342			skb = NULL;
  1343	
  1344			/* send now if this NDP is full */
  1345			if (index >= CDC_NCM_DPT_DATAGRAMS_MAX) {
  1346				ready2send = 1;
  1347				ctx->tx_reason_ndp_full++;	/* count reason for transmitting */
  1348				break;
  1349			}
  1350		}
  1351	
  1352		/* free up any dangling skb */
  1353		if (skb != NULL) {
  1354			dev_kfree_skb_any(skb);
  1355			skb = NULL;
  1356			dev->net->stats.tx_dropped++;
  1357		}
  1358	
  1359		ctx->tx_curr_frame_num = n;
  1360	
  1361		if (n == 0) {
  1362			/* wait for more frames */
  1363			/* push variables */
  1364			ctx->tx_curr_skb = skb_out;
  1365			goto exit_no_skb;
  1366	
  1367		} else if ((n < ctx->tx_max_datagrams) && (ready2send == 0) && (ctx->timer_interval > 0)) {
  1368			/* wait for more frames */
  1369			/* push variables */
  1370			ctx->tx_curr_skb = skb_out;
  1371			/* set the pending count */
  1372			if (n < CDC_NCM_RESTART_TIMER_DATAGRAM_CNT)
  1373				ctx->tx_timer_pending = CDC_NCM_TIMER_PENDING_CNT;
  1374			goto exit_no_skb;
  1375	
  1376		} else {
  1377			if (n == ctx->tx_max_datagrams)
  1378				ctx->tx_reason_max_datagram++;	/* count reason for transmitting */
  1379			/* frame goes out */
  1380			/* variables will be reset at next call */
  1381		}
  1382	
  1383		/* If requested, put NDP at end of frame. */
  1384		if (ctx->drvflags & CDC_NCM_FLAG_NDP_TO_END) {
  1385			if (ctx->is_ndp16) {
  1386				nth.nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data;
  1387				cdc_ncm_align_tail(skb_out, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size - ctx->max_ndp_size);
  1388				nth.nth16->wNdpIndex = cpu_to_le16(skb_out->len);
  1389				skb_put_data(skb_out, ctx->delayed_ndp16, ctx->max_ndp_size);
  1390	
  1391				/* Zero out delayed NDP - signature checking will naturally fail. */
  1392				ndp.ndp16 = memset(ctx->delayed_ndp16, 0, ctx->max_ndp_size);
  1393			} else {
  1394				nth.nth32 = (struct usb_cdc_ncm_nth32 *)skb_out->data;
  1395				cdc_ncm_align_tail(skb_out, ctx->tx_ndp_modulus, 0, ctx->tx_curr_size - ctx->max_ndp_size);
  1396				nth.nth32->dwNdpIndex = cpu_to_le32(skb_out->len);
  1397				skb_put_data(skb_out, ctx->delayed_ndp32, ctx->max_ndp_size);
  1398	
  1399				ndp.ndp32 = memset(ctx->delayed_ndp32, 0, ctx->max_ndp_size);
  1400			}
  1401		}
  1402	
  1403		/* If collected data size is less or equal ctx->min_tx_pkt
  1404		 * bytes, we send buffers as it is. If we get more data, it
  1405		 * would be more efficient for USB HS mobile device with DMA
  1406		 * engine to receive a full size NTB, than canceling DMA
  1407		 * transfer and receiving a short packet.
  1408		 *
  1409		 * This optimization support is pointless if we end up sending
  1410		 * a ZLP after full sized NTBs.
  1411		 */
  1412		if (!(dev->driver_info->flags & FLAG_SEND_ZLP) &&
  1413		    skb_out->len > ctx->min_tx_pkt) {
  1414			padding_count = ctx->tx_curr_size - skb_out->len;
  1415			if (!WARN_ON(padding_count > ctx->tx_curr_size))
  1416				skb_put_zero(skb_out, padding_count);
  1417		} else if (skb_out->len < ctx->tx_curr_size &&
  1418			   (skb_out->len % dev->maxpacket) == 0) {
  1419			skb_put_u8(skb_out, 0);	/* force short packet */
  1420		}
  1421	
  1422		/* set final frame length */
  1423		if (ctx->is_ndp16) {
  1424			nth.nth16 = (struct usb_cdc_ncm_nth16 *)skb_out->data;
  1425			nth.nth16->wBlockLength = cpu_to_le16(skb_out->len);
  1426		} else {
  1427			nth.nth32 = (struct usb_cdc_ncm_nth32 *)skb_out->data;
  1428			nth.nth32->dwBlockLength = cpu_to_le32(skb_out->len);
  1429		}
  1430	
  1431		/* return skb */
  1432		ctx->tx_curr_skb = NULL;
  1433	
  1434		/* keep private stats: framing overhead and number of NTBs */
  1435		ctx->tx_overhead += skb_out->len - ctx->tx_curr_frame_payload;
  1436		ctx->tx_ntbs++;
  1437	
  1438		/* usbnet will count all the framing overhead by default.
  1439		 * Adjust the stats so that the tx_bytes counter show real
  1440		 * payload data instead.
  1441		 */
  1442		usbnet_set_skb_tx_stats(skb_out, n,
  1443					(long)ctx->tx_curr_frame_payload - skb_out->len);
  1444	
  1445		return skb_out;
  1446	
  1447	exit_no_skb:
  1448		/* Start timer, if there is a remaining non-empty skb */
  1449		if (ctx->tx_curr_skb != NULL && n > 0)
  1450			cdc_ncm_tx_timeout_start(ctx);
  1451		return NULL;
  1452	}
  1453	EXPORT_SYMBOL_GPL(cdc_ncm_fill_tx_frame);
  1454	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

Download attachment ".config.gz" of type "application/gzip" (39905 bytes)

Powered by blists - more mailing lists