Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 4f8f61eb4341be07b4a8d046f646fcf934a89949

Authored by Yang Yingliang
Committed by David S. Miller
1 parent 9319e47c18
Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch imx_3.14.28_1.0.0_ga

net_sched: expand control flow of macro SKIP_NONLOCAL 

SKIP_NONLOCAL hides the control flow. The control flow should be
inlined and expanded explicitly in code so that someone who reads
it can tell the control flow can be changed by the statement.

Signed-off-by: Yang Yingliang <yangyingliang@huawei.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 1 changed file with 122 additions and 35 deletions Side-by-side Diff

... ... @@ -271,40 +271,52 @@
271 271 * Socket Attributes
272 272 **************************************************************************/
273 273  
274   -#define SKIP_NONLOCAL(skb) \
275   - if (unlikely(skb->sk == NULL)) { \
276   - *err = -1; \
277   - return; \
278   - }
  274 +#define skip_nonlocal(skb) \
  275 + (unlikely(skb->sk == NULL))
279 276  
280 277 META_COLLECTOR(int_sk_family)
281 278 {
282   - SKIP_NONLOCAL(skb);
  279 + if (skip_nonlocal(skb)) {
  280 + *err = -1;
  281 + return;
  282 + }
283 283 dst->value = skb->sk->sk_family;
284 284 }
285 285  
286 286 META_COLLECTOR(int_sk_state)
287 287 {
288   - SKIP_NONLOCAL(skb);
  288 + if (skip_nonlocal(skb)) {
  289 + *err = -1;
  290 + return;
  291 + }
289 292 dst->value = skb->sk->sk_state;
290 293 }
291 294  
292 295 META_COLLECTOR(int_sk_reuse)
293 296 {
294   - SKIP_NONLOCAL(skb);
  297 + if (skip_nonlocal(skb)) {
  298 + *err = -1;
  299 + return;
  300 + }
295 301 dst->value = skb->sk->sk_reuse;
296 302 }
297 303  
298 304 META_COLLECTOR(int_sk_bound_if)
299 305 {
300   - SKIP_NONLOCAL(skb);
  306 + if (skip_nonlocal(skb)) {
  307 + *err = -1;
  308 + return;
  309 + }
301 310 /* No error if bound_dev_if is 0, legal userspace check */
302 311 dst->value = skb->sk->sk_bound_dev_if;
303 312 }
304 313  
305 314 META_COLLECTOR(var_sk_bound_if)
306 315 {
307   - SKIP_NONLOCAL(skb);
  316 + if (skip_nonlocal(skb)) {
  317 + *err = -1;
  318 + return;
  319 + }
308 320  
309 321 if (skb->sk->sk_bound_dev_if == 0) {
310 322 dst->value = (unsigned long) "any";
311 323  
312 324  
313 325  
314 326  
315 327  
316 328  
317 329  
318 330  
319 331  
320 332  
321 333  
322 334  
323 335  
324 336  
325 337  
326 338  
327 339  
328 340  
329 341  
330 342  
331 343  
332 344  
333 345  
334 346  
... ... @@ -322,151 +334,226 @@
322 334  
323 335 META_COLLECTOR(int_sk_refcnt)
324 336 {
325   - SKIP_NONLOCAL(skb);
  337 + if (skip_nonlocal(skb)) {
  338 + *err = -1;
  339 + return;
  340 + }
326 341 dst->value = atomic_read(&skb->sk->sk_refcnt);
327 342 }
328 343  
329 344 META_COLLECTOR(int_sk_rcvbuf)
330 345 {
331   - SKIP_NONLOCAL(skb);
  346 + if (skip_nonlocal(skb)) {
  347 + *err = -1;
  348 + return;
  349 + }
332 350 dst->value = skb->sk->sk_rcvbuf;
333 351 }
334 352  
335 353 META_COLLECTOR(int_sk_shutdown)
336 354 {
337   - SKIP_NONLOCAL(skb);
  355 + if (skip_nonlocal(skb)) {
  356 + *err = -1;
  357 + return;
  358 + }
338 359 dst->value = skb->sk->sk_shutdown;
339 360 }
340 361  
341 362 META_COLLECTOR(int_sk_proto)
342 363 {
343   - SKIP_NONLOCAL(skb);
  364 + if (skip_nonlocal(skb)) {
  365 + *err = -1;
  366 + return;
  367 + }
344 368 dst->value = skb->sk->sk_protocol;
345 369 }
346 370  
347 371 META_COLLECTOR(int_sk_type)
348 372 {
349   - SKIP_NONLOCAL(skb);
  373 + if (skip_nonlocal(skb)) {
  374 + *err = -1;
  375 + return;
  376 + }
350 377 dst->value = skb->sk->sk_type;
351 378 }
352 379  
353 380 META_COLLECTOR(int_sk_rmem_alloc)
354 381 {
355   - SKIP_NONLOCAL(skb);
  382 + if (skip_nonlocal(skb)) {
  383 + *err = -1;
  384 + return;
  385 + }
356 386 dst->value = sk_rmem_alloc_get(skb->sk);
357 387 }
358 388  
359 389 META_COLLECTOR(int_sk_wmem_alloc)
360 390 {
361   - SKIP_NONLOCAL(skb);
  391 + if (skip_nonlocal(skb)) {
  392 + *err = -1;
  393 + return;
  394 + }
362 395 dst->value = sk_wmem_alloc_get(skb->sk);
363 396 }
364 397  
365 398 META_COLLECTOR(int_sk_omem_alloc)
366 399 {
367   - SKIP_NONLOCAL(skb);
  400 + if (skip_nonlocal(skb)) {
  401 + *err = -1;
  402 + return;
  403 + }
368 404 dst->value = atomic_read(&skb->sk->sk_omem_alloc);
369 405 }
370 406  
371 407 META_COLLECTOR(int_sk_rcv_qlen)
372 408 {
373   - SKIP_NONLOCAL(skb);
  409 + if (skip_nonlocal(skb)) {
  410 + *err = -1;
  411 + return;
  412 + }
374 413 dst->value = skb->sk->sk_receive_queue.qlen;
375 414 }
376 415  
377 416 META_COLLECTOR(int_sk_snd_qlen)
378 417 {
379   - SKIP_NONLOCAL(skb);
  418 + if (skip_nonlocal(skb)) {
  419 + *err = -1;
  420 + return;
  421 + }
380 422 dst->value = skb->sk->sk_write_queue.qlen;
381 423 }
382 424  
383 425 META_COLLECTOR(int_sk_wmem_queued)
384 426 {
385   - SKIP_NONLOCAL(skb);
  427 + if (skip_nonlocal(skb)) {
  428 + *err = -1;
  429 + return;
  430 + }
386 431 dst->value = skb->sk->sk_wmem_queued;
387 432 }
388 433  
389 434 META_COLLECTOR(int_sk_fwd_alloc)
390 435 {
391   - SKIP_NONLOCAL(skb);
  436 + if (skip_nonlocal(skb)) {
  437 + *err = -1;
  438 + return;
  439 + }
392 440 dst->value = skb->sk->sk_forward_alloc;
393 441 }
394 442  
395 443 META_COLLECTOR(int_sk_sndbuf)
396 444 {
397   - SKIP_NONLOCAL(skb);
  445 + if (skip_nonlocal(skb)) {
  446 + *err = -1;
  447 + return;
  448 + }
398 449 dst->value = skb->sk->sk_sndbuf;
399 450 }
400 451  
401 452 META_COLLECTOR(int_sk_alloc)
402 453 {
403   - SKIP_NONLOCAL(skb);
  454 + if (skip_nonlocal(skb)) {
  455 + *err = -1;
  456 + return;
  457 + }
404 458 dst->value = (__force int) skb->sk->sk_allocation;
405 459 }
406 460  
407 461 META_COLLECTOR(int_sk_hash)
408 462 {
409   - SKIP_NONLOCAL(skb);
  463 + if (skip_nonlocal(skb)) {
  464 + *err = -1;
  465 + return;
  466 + }
410 467 dst->value = skb->sk->sk_hash;
411 468 }
412 469  
413 470 META_COLLECTOR(int_sk_lingertime)
414 471 {
415   - SKIP_NONLOCAL(skb);
  472 + if (skip_nonlocal(skb)) {
  473 + *err = -1;
  474 + return;
  475 + }
416 476 dst->value = skb->sk->sk_lingertime / HZ;
417 477 }
418 478  
419 479 META_COLLECTOR(int_sk_err_qlen)
420 480 {
421   - SKIP_NONLOCAL(skb);
  481 + if (skip_nonlocal(skb)) {
  482 + *err = -1;
  483 + return;
  484 + }
422 485 dst->value = skb->sk->sk_error_queue.qlen;
423 486 }
424 487  
425 488 META_COLLECTOR(int_sk_ack_bl)
426 489 {
427   - SKIP_NONLOCAL(skb);
  490 + if (skip_nonlocal(skb)) {
  491 + *err = -1;
  492 + return;
  493 + }
428 494 dst->value = skb->sk->sk_ack_backlog;
429 495 }
430 496  
431 497 META_COLLECTOR(int_sk_max_ack_bl)
432 498 {
433   - SKIP_NONLOCAL(skb);
  499 + if (skip_nonlocal(skb)) {
  500 + *err = -1;
  501 + return;
  502 + }
434 503 dst->value = skb->sk->sk_max_ack_backlog;
435 504 }
436 505  
437 506 META_COLLECTOR(int_sk_prio)
438 507 {
439   - SKIP_NONLOCAL(skb);
  508 + if (skip_nonlocal(skb)) {
  509 + *err = -1;
  510 + return;
  511 + }
440 512 dst->value = skb->sk->sk_priority;
441 513 }
442 514  
443 515 META_COLLECTOR(int_sk_rcvlowat)
444 516 {
445   - SKIP_NONLOCAL(skb);
  517 + if (skip_nonlocal(skb)) {
  518 + *err = -1;
  519 + return;
  520 + }
446 521 dst->value = skb->sk->sk_rcvlowat;
447 522 }
448 523  
449 524 META_COLLECTOR(int_sk_rcvtimeo)
450 525 {
451   - SKIP_NONLOCAL(skb);
  526 + if (skip_nonlocal(skb)) {
  527 + *err = -1;
  528 + return;
  529 + }
452 530 dst->value = skb->sk->sk_rcvtimeo / HZ;
453 531 }
454 532  
455 533 META_COLLECTOR(int_sk_sndtimeo)
456 534 {
457   - SKIP_NONLOCAL(skb);
  535 + if (skip_nonlocal(skb)) {
  536 + *err = -1;
  537 + return;
  538 + }
458 539 dst->value = skb->sk->sk_sndtimeo / HZ;
459 540 }
460 541  
461 542 META_COLLECTOR(int_sk_sendmsg_off)
462 543 {
463   - SKIP_NONLOCAL(skb);
  544 + if (skip_nonlocal(skb)) {
  545 + *err = -1;
  546 + return;
  547 + }
464 548 dst->value = skb->sk->sk_frag.offset;
465 549 }
466 550  
467 551 META_COLLECTOR(int_sk_write_pend)
468 552 {
469   - SKIP_NONLOCAL(skb);
  553 + if (skip_nonlocal(skb)) {
  554 + *err = -1;
  555 + return;
  556 + }
470 557 dst->value = skb->sk->sk_write_pending;
471 558 }
472 559