← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to net/ipv4/tcp.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/ipv4/tcp.c
505
505
                else
506
506
                        answ = tp->write_seq - tp->snd_una;
507
507
                break;
 
508
        case SIOCOUTQNSD:
 
509
                if (sk->sk_state == TCP_LISTEN)
 
510
                        return -EINVAL;
 
511
 
 
512
                if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
 
513
                        answ = 0;
 
514
                else
 
515
                        answ = tp->write_seq - tp->snd_nxt;
 
516
                break;
508
517
        default:
509
518
                return -ENOIOCTLCMD;
510
519
        }
873
882
                                        flags);
874
883
 
875
884
        lock_sock(sk);
876
 
        TCP_CHECK_TIMER(sk);
877
885
        res = do_tcp_sendpages(sk, &page, offset, size, flags);
878
 
        TCP_CHECK_TIMER(sk);
879
886
        release_sock(sk);
880
887
        return res;
881
888
}
916
923
        long timeo;
917
924
 
918
925
        lock_sock(sk);
919
 
        TCP_CHECK_TIMER(sk);
920
926
 
921
927
        flags = msg->msg_flags;
922
928
        timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
993
999
                                /* We have some space in skb head. Superb! */
994
1000
                                if (copy > skb_tailroom(skb))
995
1001
                                        copy = skb_tailroom(skb);
996
 
                                if ((err = skb_add_data(skb, from, copy)) != 0)
 
1002
                                err = skb_add_data_nocache(sk, skb, from, copy);
 
1003
                                if (err)
997
1004
                                        goto do_fault;
998
1005
                        } else {
999
1006
                                int merge = 0;
1036
1043
 
1037
1044
                                /* Time to copy data. We are close to
1038
1045
                                 * the end! */
1039
 
                                err = skb_copy_to_page(sk, from, skb, page,
1040
 
                                                       off, copy);
 
1046
                                err = skb_copy_to_page_nocache(sk, from, skb,
 
1047
                                                               page, off, copy);
1041
1048
                                if (err) {
1042
1049
                                        /* If this page was new, give it to the
1043
1050
                                         * socket so it does not get leaked.
1104
1111
out:
1105
1112
        if (copied)
1106
1113
                tcp_push(sk, flags, mss_now, tp->nonagle);
1107
 
        TCP_CHECK_TIMER(sk);
1108
1114
        release_sock(sk);
1109
1115
        return copied;
1110
1116
 
1123
1129
                goto out;
1124
1130
out_err:
1125
1131
        err = sk_stream_error(sk, flags, err);
1126
 
        TCP_CHECK_TIMER(sk);
1127
1132
        release_sock(sk);
1128
1133
        return err;
1129
1134
}
1415
1420
 
1416
1421
        lock_sock(sk);
1417
1422
 
1418
 
        TCP_CHECK_TIMER(sk);
1419
 
 
1420
1423
        err = -ENOTCONN;
1421
1424
        if (sk->sk_state == TCP_LISTEN)
1422
1425
                goto out;
1767
1770
        /* Clean up data we have read: This will do ACK frames. */
1768
1771
        tcp_cleanup_rbuf(sk, copied);
1769
1772
 
1770
 
        TCP_CHECK_TIMER(sk);
1771
1773
        release_sock(sk);
1772
1774
        return copied;
1773
1775
 
1774
1776
out:
1775
 
        TCP_CHECK_TIMER(sk);
1776
1777
        release_sock(sk);
1777
1778
        return err;
1778
1779
 
2653
2654
EXPORT_SYMBOL(compat_tcp_getsockopt);
2654
2655
#endif
2655
2656
 
2656
 
struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features)
 
2657
struct sk_buff *tcp_tso_segment(struct sk_buff *skb, u32 features)
2657
2658
{
2658
2659
        struct sk_buff *segs = ERR_PTR(-EINVAL);
2659
2660
        struct tcphdr *th;
3219
3220
void __init tcp_init(void)
3220
3221
{
3221
3222
        struct sk_buff *skb = NULL;
3222
 
        unsigned long nr_pages, limit;
 
3223
        unsigned long limit;
3223
3224
        int i, max_share, cnt;
3224
3225
        unsigned long jiffy = jiffies;
3225
3226
 
3276
3277
        sysctl_tcp_max_orphans = cnt / 2;
3277
3278
        sysctl_max_syn_backlog = max(128, cnt / 256);
3278
3279
 
3279
 
        /* Set the pressure threshold to be a fraction of global memory that
3280
 
         * is up to 1/2 at 256 MB, decreasing toward zero with the amount of
3281
 
         * memory, with a floor of 128 pages.
3282
 
         */
3283
 
        nr_pages = totalram_pages - totalhigh_pages;
3284
 
        limit = min(nr_pages, 1UL<<(28-PAGE_SHIFT)) >> (20-PAGE_SHIFT);
3285
 
        limit = (limit * (nr_pages >> (20-PAGE_SHIFT))) >> (PAGE_SHIFT-11);
 
3280
        limit = nr_free_buffer_pages() / 8;
3286
3281
        limit = max(limit, 128UL);
3287
3282
        sysctl_tcp_mem[0] = limit / 4 * 3;
3288
3283
        sysctl_tcp_mem[1] = limit;