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

net/core/skbuff.c: Use frag list abstraction interfaces.

Signed-off-by: David S. Miller <davem@davemloft.net>

+102 -120
+102 -120
net/core/skbuff.c
··· 210 210 shinfo->gso_type = 0; 211 211 shinfo->ip6_frag_id = 0; 212 212 shinfo->tx_flags.flags = 0; 213 - shinfo->frag_list = NULL; 213 + skb_frag_list_init(skb); 214 214 memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps)); 215 215 216 216 if (fclone) { ··· 323 323 { 324 324 struct sk_buff *list; 325 325 326 - for (list = skb_shinfo(skb)->frag_list; list; list = list->next) 326 + skb_walk_frags(skb, list) 327 327 skb_get(list); 328 328 } 329 329 ··· 338 338 put_page(skb_shinfo(skb)->frags[i].page); 339 339 } 340 340 341 - if (skb_shinfo(skb)->frag_list) 341 + if (skb_has_frags(skb)) 342 342 skb_drop_fraglist(skb); 343 343 344 344 kfree(skb->head); ··· 503 503 shinfo->gso_type = 0; 504 504 shinfo->ip6_frag_id = 0; 505 505 shinfo->tx_flags.flags = 0; 506 - shinfo->frag_list = NULL; 506 + skb_frag_list_init(skb); 507 507 memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps)); 508 508 509 509 memset(skb, 0, offsetof(struct sk_buff, tail)); ··· 758 758 skb_shinfo(n)->nr_frags = i; 759 759 } 760 760 761 - if (skb_shinfo(skb)->frag_list) { 761 + if (skb_has_frags(skb)) { 762 762 skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list; 763 763 skb_clone_fraglist(n); 764 764 } ··· 821 821 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) 822 822 get_page(skb_shinfo(skb)->frags[i].page); 823 823 824 - if (skb_shinfo(skb)->frag_list) 824 + if (skb_has_frags(skb)) 825 825 skb_clone_fraglist(skb); 826 826 827 827 skb_release_data(skb); ··· 1093 1093 for (; i < nfrags; i++) 1094 1094 put_page(skb_shinfo(skb)->frags[i].page); 1095 1095 1096 - if (skb_shinfo(skb)->frag_list) 1096 + if (skb_has_frags(skb)) 1097 1097 skb_drop_fraglist(skb); 1098 1098 goto done; 1099 1099 } ··· 1188 1188 /* Optimization: no fragments, no reasons to preestimate 1189 1189 * size of pulled pages. Superb. 1190 1190 */ 1191 - if (!skb_shinfo(skb)->frag_list) 1191 + if (!skb_has_frags(skb)) 1192 1192 goto pull_pages; 1193 1193 1194 1194 /* Estimate size of pulled pages. */ ··· 1285 1285 1286 1286 int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len) 1287 1287 { 1288 - int i, copy; 1289 1288 int start = skb_headlen(skb); 1289 + struct sk_buff *frag_iter; 1290 + int i, copy; 1290 1291 1291 1292 if (offset > (int)skb->len - len) 1292 1293 goto fault; ··· 1329 1328 start = end; 1330 1329 } 1331 1330 1332 - if (skb_shinfo(skb)->frag_list) { 1333 - struct sk_buff *list = skb_shinfo(skb)->frag_list; 1331 + skb_walk_frags(skb, frag_iter) { 1332 + int end; 1334 1333 1335 - for (; list; list = list->next) { 1336 - int end; 1334 + WARN_ON(start > offset + len); 1337 1335 1338 - WARN_ON(start > offset + len); 1339 - 1340 - end = start + list->len; 1341 - if ((copy = end - offset) > 0) { 1342 - if (copy > len) 1343 - copy = len; 1344 - if (skb_copy_bits(list, offset - start, 1345 - to, copy)) 1346 - goto fault; 1347 - if ((len -= copy) == 0) 1348 - return 0; 1349 - offset += copy; 1350 - to += copy; 1351 - } 1352 - start = end; 1336 + end = start + frag_iter->len; 1337 + if ((copy = end - offset) > 0) { 1338 + if (copy > len) 1339 + copy = len; 1340 + if (skb_copy_bits(frag_iter, offset - start, to, copy)) 1341 + goto fault; 1342 + if ((len -= copy) == 0) 1343 + return 0; 1344 + offset += copy; 1345 + to += copy; 1353 1346 } 1347 + start = end; 1354 1348 } 1355 1349 if (!len) 1356 1350 return 0; ··· 1530 1534 .ops = &sock_pipe_buf_ops, 1531 1535 .spd_release = sock_spd_release, 1532 1536 }; 1537 + struct sk_buff *frag_iter; 1533 1538 struct sock *sk = skb->sk; 1534 1539 1535 1540 /* ··· 1545 1548 /* 1546 1549 * now see if we have a frag_list to map 1547 1550 */ 1548 - if (skb_shinfo(skb)->frag_list) { 1549 - struct sk_buff *list = skb_shinfo(skb)->frag_list; 1550 - 1551 - for (; list && tlen; list = list->next) { 1552 - if (__skb_splice_bits(list, &offset, &tlen, &spd, sk)) 1553 - break; 1554 - } 1551 + skb_walk_frags(skb, frag_iter) { 1552 + if (!tlen) 1553 + break; 1554 + if (__skb_splice_bits(frag_iter, &offset, &tlen, &spd, sk)) 1555 + break; 1555 1556 } 1556 1557 1557 1558 done: ··· 1588 1593 1589 1594 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len) 1590 1595 { 1591 - int i, copy; 1592 1596 int start = skb_headlen(skb); 1597 + struct sk_buff *frag_iter; 1598 + int i, copy; 1593 1599 1594 1600 if (offset > (int)skb->len - len) 1595 1601 goto fault; ··· 1631 1635 start = end; 1632 1636 } 1633 1637 1634 - if (skb_shinfo(skb)->frag_list) { 1635 - struct sk_buff *list = skb_shinfo(skb)->frag_list; 1638 + skb_walk_frags(skb, frag_iter) { 1639 + int end; 1636 1640 1637 - for (; list; list = list->next) { 1638 - int end; 1641 + WARN_ON(start > offset + len); 1639 1642 1640 - WARN_ON(start > offset + len); 1641 - 1642 - end = start + list->len; 1643 - if ((copy = end - offset) > 0) { 1644 - if (copy > len) 1645 - copy = len; 1646 - if (skb_store_bits(list, offset - start, 1647 - from, copy)) 1648 - goto fault; 1649 - if ((len -= copy) == 0) 1650 - return 0; 1651 - offset += copy; 1652 - from += copy; 1653 - } 1654 - start = end; 1643 + end = start + frag_iter->len; 1644 + if ((copy = end - offset) > 0) { 1645 + if (copy > len) 1646 + copy = len; 1647 + if (skb_store_bits(frag_iter, offset - start, 1648 + from, copy)) 1649 + goto fault; 1650 + if ((len -= copy) == 0) 1651 + return 0; 1652 + offset += copy; 1653 + from += copy; 1655 1654 } 1655 + start = end; 1656 1656 } 1657 1657 if (!len) 1658 1658 return 0; ··· 1665 1673 { 1666 1674 int start = skb_headlen(skb); 1667 1675 int i, copy = start - offset; 1676 + struct sk_buff *frag_iter; 1668 1677 int pos = 0; 1669 1678 1670 1679 /* Checksum header. */ ··· 1705 1712 start = end; 1706 1713 } 1707 1714 1708 - if (skb_shinfo(skb)->frag_list) { 1709 - struct sk_buff *list = skb_shinfo(skb)->frag_list; 1715 + skb_walk_frags(skb, frag_iter) { 1716 + int end; 1710 1717 1711 - for (; list; list = list->next) { 1712 - int end; 1718 + WARN_ON(start > offset + len); 1713 1719 1714 - WARN_ON(start > offset + len); 1715 - 1716 - end = start + list->len; 1717 - if ((copy = end - offset) > 0) { 1718 - __wsum csum2; 1719 - if (copy > len) 1720 - copy = len; 1721 - csum2 = skb_checksum(list, offset - start, 1722 - copy, 0); 1723 - csum = csum_block_add(csum, csum2, pos); 1724 - if ((len -= copy) == 0) 1725 - return csum; 1726 - offset += copy; 1727 - pos += copy; 1728 - } 1729 - start = end; 1720 + end = start + frag_iter->len; 1721 + if ((copy = end - offset) > 0) { 1722 + __wsum csum2; 1723 + if (copy > len) 1724 + copy = len; 1725 + csum2 = skb_checksum(frag_iter, offset - start, 1726 + copy, 0); 1727 + csum = csum_block_add(csum, csum2, pos); 1728 + if ((len -= copy) == 0) 1729 + return csum; 1730 + offset += copy; 1731 + pos += copy; 1730 1732 } 1733 + start = end; 1731 1734 } 1732 1735 BUG_ON(len); 1733 1736 ··· 1738 1749 { 1739 1750 int start = skb_headlen(skb); 1740 1751 int i, copy = start - offset; 1752 + struct sk_buff *frag_iter; 1741 1753 int pos = 0; 1742 1754 1743 1755 /* Copy header. */ ··· 1783 1793 start = end; 1784 1794 } 1785 1795 1786 - if (skb_shinfo(skb)->frag_list) { 1787 - struct sk_buff *list = skb_shinfo(skb)->frag_list; 1796 + skb_walk_frags(skb, frag_iter) { 1797 + __wsum csum2; 1798 + int end; 1788 1799 1789 - for (; list; list = list->next) { 1790 - __wsum csum2; 1791 - int end; 1800 + WARN_ON(start > offset + len); 1792 1801 1793 - WARN_ON(start > offset + len); 1794 - 1795 - end = start + list->len; 1796 - if ((copy = end - offset) > 0) { 1797 - if (copy > len) 1798 - copy = len; 1799 - csum2 = skb_copy_and_csum_bits(list, 1800 - offset - start, 1801 - to, copy, 0); 1802 - csum = csum_block_add(csum, csum2, pos); 1803 - if ((len -= copy) == 0) 1804 - return csum; 1805 - offset += copy; 1806 - to += copy; 1807 - pos += copy; 1808 - } 1809 - start = end; 1802 + end = start + frag_iter->len; 1803 + if ((copy = end - offset) > 0) { 1804 + if (copy > len) 1805 + copy = len; 1806 + csum2 = skb_copy_and_csum_bits(frag_iter, 1807 + offset - start, 1808 + to, copy, 0); 1809 + csum = csum_block_add(csum, csum2, pos); 1810 + if ((len -= copy) == 0) 1811 + return csum; 1812 + offset += copy; 1813 + to += copy; 1814 + pos += copy; 1810 1815 } 1816 + start = end; 1811 1817 } 1812 1818 BUG_ON(len); 1813 1819 return csum; ··· 2313 2327 st->frag_data = NULL; 2314 2328 } 2315 2329 2316 - if (st->root_skb == st->cur_skb && 2317 - skb_shinfo(st->root_skb)->frag_list) { 2330 + if (st->root_skb == st->cur_skb && skb_has_frags(st->root_skb)) { 2318 2331 st->cur_skb = skb_shinfo(st->root_skb)->frag_list; 2319 2332 st->frag_idx = 0; 2320 2333 goto next_skb; ··· 2624 2639 } else 2625 2640 skb_get(fskb2); 2626 2641 2627 - BUG_ON(skb_shinfo(nskb)->frag_list); 2642 + SKB_FRAG_ASSERT(nskb); 2628 2643 skb_shinfo(nskb)->frag_list = fskb2; 2629 2644 } 2630 2645 ··· 2781 2796 { 2782 2797 int start = skb_headlen(skb); 2783 2798 int i, copy = start - offset; 2799 + struct sk_buff *frag_iter; 2784 2800 int elt = 0; 2785 2801 2786 2802 if (copy > 0) { ··· 2815 2829 start = end; 2816 2830 } 2817 2831 2818 - if (skb_shinfo(skb)->frag_list) { 2819 - struct sk_buff *list = skb_shinfo(skb)->frag_list; 2832 + skb_walk_frags(skb, frag_iter) { 2833 + int end; 2820 2834 2821 - for (; list; list = list->next) { 2822 - int end; 2835 + WARN_ON(start > offset + len); 2823 2836 2824 - WARN_ON(start > offset + len); 2825 - 2826 - end = start + list->len; 2827 - if ((copy = end - offset) > 0) { 2828 - if (copy > len) 2829 - copy = len; 2830 - elt += __skb_to_sgvec(list, sg+elt, offset - start, 2831 - copy); 2832 - if ((len -= copy) == 0) 2833 - return elt; 2834 - offset += copy; 2835 - } 2836 - start = end; 2837 + end = start + frag_iter->len; 2838 + if ((copy = end - offset) > 0) { 2839 + if (copy > len) 2840 + copy = len; 2841 + elt += __skb_to_sgvec(frag_iter, sg+elt, offset - start, 2842 + copy); 2843 + if ((len -= copy) == 0) 2844 + return elt; 2845 + offset += copy; 2837 2846 } 2847 + start = end; 2838 2848 } 2839 2849 BUG_ON(len); 2840 2850 return elt; ··· 2878 2896 return -ENOMEM; 2879 2897 2880 2898 /* Easy case. Most of packets will go this way. */ 2881 - if (!skb_shinfo(skb)->frag_list) { 2899 + if (!skb_has_frags(skb)) { 2882 2900 /* A little of trouble, not enough of space for trailer. 2883 2901 * This should not happen, when stack is tuned to generate 2884 2902 * good frames. OK, on miss we reallocate and reserve even more ··· 2913 2931 2914 2932 if (skb1->next == NULL && tailbits) { 2915 2933 if (skb_shinfo(skb1)->nr_frags || 2916 - skb_shinfo(skb1)->frag_list || 2934 + skb_has_frags(skb1) || 2917 2935 skb_tailroom(skb1) < tailbits) 2918 2936 ntail = tailbits + 128; 2919 2937 } ··· 2922 2940 skb_cloned(skb1) || 2923 2941 ntail || 2924 2942 skb_shinfo(skb1)->nr_frags || 2925 - skb_shinfo(skb1)->frag_list) { 2943 + skb_has_frags(skb1)) { 2926 2944 struct sk_buff *skb2; 2927 2945 2928 2946 /* Fuck, we are miserable poor guys... */