开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tcp-linux.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：28k
源码类别：

通讯编程

开发平台：

Visual C++

tcp-linux.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1990, 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms are permitted
  7.  * provided that the above copyright notice and this paragraph are
  8.  * duplicated in all such forms and that any documentation,
  9.  * advertising materials, and other materials related to such
  10.  * distribution and use acknowledge that the software was developed
  11.  * by the University of California, Lawrence Berkeley Laboratory,
  12.  * Berkeley, CA.  The name of the University may not be used to
  13.  * endorse or promote products derived from this software without
  14.  * specific prior written permission.
  15.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18.  */
  20. /* 
  21.  * TCP-Linux module for NS2 
  22.  *
  23.  * May 2006
  24.  *
  25.  * Author: Xiaoliang (David) Wei  (DavidWei@acm.org)
  26.  *
  27.  * NetLab, the California Institute of Technology 
  28.  * http://netlab.caltech.edu
  29.  *
  30.  * Module: tcp-linux.cc 
  31.  *      This is the main NS-2 module for TCP-Linux.
  32.  *
  33.  *
  34.  * See a mini-tutorial about TCP-Linux at: http://netlab.caltech.edu/projects/ns2tcplinux/
  35.  *
  36.  */
  39. #include <stdio.h>
  40. #include <stdlib.h>
  41. #include <sys/types.h>
  43. #include "ip.h"
  44. #include "tcp.h"
  45. #include "flags.h"
  46. #include "random.h"
  47. #include "tcp-linux.h"
  48. #include "template.h"
  50. CongestionControlManager cong_ops_manager;
  52. CongestionControlManager::CongestionControlManager() {
  53. scan();
  54. };
  55. void CongestionControlManager::scan() {
  56. struct tcp_congestion_ops *e;
  57. num_ = 1;
  58. list_for_each_entry_rcu(e, &ns_tcp_cong_list, list) {
  59. num_++;
  60. };
  61. ops_list = new struct tcp_congestion_ops*[num_];
  63. ops_list[0] = &tcp_reno;
  64. int i=1;
  65. list_for_each_entry_rcu(e, &tcp_cong_list, list) {
  66. ops_list[i] = e;
  67. i++;
  68. }
  69. cc_list_changed = 0;
  70. //printf("congestion control algorithm initializedn");
  71. };
  73. struct tcp_congestion_ops* CongestionControlManager::get_ops(const char* name) {
  74. if (cc_list_changed) scan();
  75. for (int i=0; i< num_; i++) {
  76. if (strcmp(name, ops_list[i]->name)==0)
  77. return ops_list[i];
  78. }
  79. return 0;
  80. };
  82. void CongestionControlManager::dump() {
  83. printf("List of cc (total %d) :", num_);
  84. for (int i=0; i< num_; i++) {
  85. printf(" %s", ops_list[i]->name);
  86. }
  87. printf("n");
  88. };
  92. static class LinuxTcpClass : public TclClass {
  93. public:
  94. LinuxTcpClass() : TclClass("Agent/TCP/Linux") {}
  95. TclObject* create(int, const char*const*) {
  96. return (new LinuxTcpAgent());
  97. }
  98. } class_linux;
  101. LinuxTcpAgent::LinuxTcpAgent() :
  102. initialized_(false),
  103. next_pkts_in_flight_(0)
  104. {
  105. bind("next_pkts_in_flight_", &next_pkts_in_flight_);
  106. scb_ = new ScoreBoard1();
  107. linux_.icsk_ca_ops = NULL;
  108.         linux_.snd_cwnd_stamp = 0;
  109. linux_.icsk_ca_state = TCP_CA_Open;
  110. linux_.snd_cwnd = 2;
  111. linux_.snd_cwnd_cnt = 0;
  112. linux_.bytes_acked = 0;
  113. //load_to_linux_once();
  114. // scb_->test();
  115. }
  117. LinuxTcpAgent::~LinuxTcpAgent(){
  118. delete scb_;
  119. remove_congestion_control();
  120. }
  122. int LinuxTcpAgent::window() 
  123. {
  124. return (linux_.snd_cwnd);
  125. }
  126. double LinuxTcpAgent::windowd()
  127. {
  128. return (linux_.snd_cwnd);
  129. //+ min((double)linux_.snd_cwnd_cnt/(double)linux_.snd_cwnd, 1));
  130. }
  131. void LinuxTcpAgent::reset()
  132. {
  133. scb_->ClearScoreBoard();
  134. linux_.icsk_ca_state = TCP_CA_Open;
  135. linux_.snd_cwnd_stamp = 0;
  136. linux_.snd_cwnd = 2;
  137. linux_.bytes_acked = 0;
  138. initialized_ = false;
  140. TcpAgent::reset();
  142. load_to_linux_once();
  143. load_to_linux();
  144. }
  146. ////////////////// Ack processing part //////////////////////////////
  147. unsigned char LinuxTcpAgent::ack_processing(Packet* pkt, unsigned char flag)
  148. {
  149. hdr_tcp *tcph = hdr_tcp::access(pkt);
  150. //update sequence numbers
  151. if (flag&FLAG_DATA_ACKED) {
  152. highest_ack_ = tcph->seqno();
  153. linux_.snd_una = (highest_ack_+1)*linux_.mss_cache;
  154. maxseq_ = max(maxseq_, highest_ack_);
  155. if (t_seqno_ < highest_ack_ + 1) {
  156. t_seqno_ = highest_ack_ + 1;
  157. linux_.snd_nxt = t_seqno_*linux_.mss_cache;
  158. }
  159. return flag;
  160. } else {
  161. return flag | FLAG_UNSURE_TSTAMP;
  162. };
  163. }
  164. void LinuxTcpAgent::time_processing(Packet* pkt, unsigned char flag, s32* seq_urtt_p/*, s32* seq_usrtt_p*/)
  165. {
  166.         hdr_tcp *tcph = hdr_tcp::access(pkt);
  168. #define renew_timer {if (t_seqno_ > highest_ack_|| highest_ack_< maxseq_ || linux_.snd_cwnd < 1) set_rtx_timer(); else cancel_rtx_timer();}
  169. if (!timerfix_) renew_timer;
  171. //update time:
  172. double now = Scheduler::instance().clock();
  173. ts_peer_ = tcph->ts();          //record timestamp for echoing
  175. /* 
  176.  * Update RTT only if it's OK to do so from info in the flags header.
  177.  * This is needed for protocols in which intermediate agents
  178.  * in the network intersperse acks (e.g., ack-reconstructors) for
  179.  * various reasons (without violating e2e semantics).
  180.  */
  181. hdr_flags *fh = hdr_flags::access(pkt);
  182. linux_.rx_opt.saw_tstamp = 0;
  183. if (!fh->no_ts_) {
  184. if (ts_option_) {
  185. ts_echo_ = tcph->ts_echo();
  186. linux_.rx_opt.saw_tstamp = 1;
  187. linux_.rx_opt.rcv_tsecr = (__u32) (round(ts_echo_*JIFFY_RATIO));
  188. linux_.rx_opt.rcv_tsval = (__u32) (round(tcph->ts()*JIFFY_RATIO));
  189. if (flag & FLAG_UNSURE_TSTAMP)
  190. // we are not sure which packet generates this ack
  191. rtt_update(now - tcph->ts_echo(), 0);
  192. else
  193. //we are sure this packet generates this ack
  194. rtt_update(now - tcph->ts_echo(), tcph->seqno());
  195. (*seq_urtt_p) = (s32)(round((now - tcph->ts_echo())*JIFFY_RATIO));
  196. /*(*seq_usrtt_p) = (s32)(round((now - tcph->ts_echo())*US_RATIO));*/
  197. if (ts_resetRTO_) { 
  198. t_backoff_ = 1;
  199. if (!ect_ || !ecn_backoff_ || !hdr_flags::access(pkt)->ecnecho()) { 
  200. // From Andrei Gurtov
  201. /* 
  202.  * Don't end backoff if still in ECN-Echo with
  203.    * a congestion window of 1 packet. 
  204.  */
  205. ecn_backoff_ = 0;
  206. }
  207. }
  208. }
  209. }
  210. if (rtt_active_ && tcph->seqno() >= rtt_seq_) {
  211. if (!ect_ || !ecn_backoff_ || 
  212. !hdr_flags::access(pkt)->ecnecho()) {
  213. /* 
  214.  * Don't end backoff if still in ECN-Echo with
  215.    * a congestion window of 1 packet. 
  216.  */
  217. t_backoff_ = 1;
  218. ecn_backoff_ = 0;
  219. }
  220. rtt_active_ = 0;
  221. if (!linux_.rx_opt.saw_tstamp)
  222. rtt_update(now - rtt_ts_, 0);
  223. }
  226. if (timerfix_) renew_timer;
  227. /* update average window */
  228. awnd_ *= 1.0 - wnd_th_;
  229. awnd_ += wnd_th_ * cwnd_;
  230. /* if the connection is done, call finish() */
  231. if ((highest_ack_ >= curseq_-1) && !closed_) {
  232. closed_ = 1;
  233. finish();
  234. }
  235. };
  237. void LinuxTcpAgent::rtt_update(double tao, unsigned long pkt_seq_no)
  238. {
  239. double now = Scheduler::instance().clock();
  240. if (ts_option_)
  241. t_rtt_ = int(tao /tcp_tick_ + 0.5);
  242. else {
  243. double sendtime = now - tao;
  244. sendtime += boot_time_;
  245. double tickoff = fmod(sendtime, tcp_tick_);
  246. t_rtt_ = int((tao + tickoff) / tcp_tick_);
  247. }
  250. /*Record microsecond timestamp*/
  251. if ((linux_.icsk_ca_ops) && (linux_.icsk_ca_ops->rtt_sample)) {
  252. if ( bugfix_ts_ && pkt_seq_no && tss ) {
  253. //if we use the tss value when we have the timestamp
  255. //unsigned long a = (unsigned long)(round((now-tss[pkt_seq_no % tss_size_])*US_RATIO));
  256. //unsigned long ha = highest_ack_;
  257. //if (a < 100)
  258. //printf("%lf (%p): RTT=%lu, seq:%lu, highest_ack:%lu tss_size: %lu timesamp:%lfn", now, this, a, pkt_seq_no, ha, tss_size_, tss[pkt_seq_no % tss_size_]);
  260. linux_.icsk_ca_ops->rtt_sample(&linux_, (unsigned long)(round((now-tss[pkt_seq_no % tss_size_])*US_RATIO)));
  261. } else { 
  262. //otherwise, use an approximation
  263. linux_.icsk_ca_ops->rtt_sample(&linux_, (unsigned long)(round(tao*US_RATIO)));
  264. }
  265. }
  267. if (t_rtt_ < 1)
  268. t_rtt_ = 1;
  269. //
  270. // t_srtt_ has 3 bits to the right of the binary point
  271. // t_rttvar_ has 2
  272.         // Thus "t_srtt_ >> T_SRTT_BITS" is the actual srtt, 
  273.    //   and "t_srtt_" is 8*srtt.
  274. // Similarly, "t_rttvar_ >> T_RTTVAR_BITS" is the actual rttvar,
  275. //   and "t_rttvar_" is 4*rttvar.
  276. //
  277.         if (t_srtt_ != 0) {
  278. register short delta;
  279. delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS); // d = (m - a0)
  280. if ((t_srtt_ += delta) <= 0) // a1 = 7/8 a0 + 1/8 m
  281. t_srtt_ = 1;
  282. if (delta < 0) {
  283. delta = -delta;
  284. delta -= (t_rttvar_ >> T_RTTVAR_BITS);
  285. if (delta>0)
  286. delta >>= T_SRTT_BITS;
  287. } else 
  288. delta -= (t_rttvar_ >> T_RTTVAR_BITS);
  289. t_rttvar_ += delta;
  290. // if ((t_rttvar_ += delta) <= 0) // var1 = 3/4 var0 + 1/4 |d|
  291. // t_rttvar_ = 1;
  292. } else {
  293. t_srtt_ = t_rtt_ << T_SRTT_BITS; // srtt = rtt
  294. t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1); // rttvar = rtt / 2
  295. }
  296. //
  297. // Current retransmit value is 
  298. //    (unscaled) smoothed round trip estimate
  299. //    plus 2^rttvar_exp_ times (unscaled) rttvar. 
  300. //
  301. t_rtxcur_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS))) +
  302. t_srtt_)  >> T_SRTT_BITS ) * tcp_tick_;
  303. linux_.srtt = t_srtt_;
  304. return;
  305. }
  307. void LinuxTcpAgent::recv(Packet *pkt, Handler*)
  308. //equivalence to tcp_ack
  309. {
  310. hdr_tcp *tcph = hdr_tcp::access(pkt);
  312. struct sock* sk = &linux_;
  313. u32 prior_snd_una = highest_ack_+1;
  314. u32 ack = tcph->seqno()+1; //in linux, the concept of unack is one packet ahead (first non-acked)
  315. u32 prior_in_flight;
  316. s32 seq_rtt;
  317. unsigned char flag=0;
  319. tcp_time_stamp = (unsigned long) (trunc(Scheduler::instance().clock() * JIFFY_RATIO)); 
  320. ktime_get_real = (s64)trunc(Scheduler::instance().clock()*1000000000);
  321. #ifdef notdef
  322. if (pkt->type_ != PT_ACK) {
  323. Tcl::instance().evalf("%s error "received non-ack"",
  324.       name());
  325. Packet::free(pkt);
  326. return;
  327. }
  328. #endif
  330. ++nackpack_;
  333. if (ack > (unsigned long)t_seqno_) return;  // uninteresting_ack
  334. if (ack < prior_snd_una) return; // old_ack; only worth for D-SACK. but let's pass it.
  336. DEBUG(5, "received an ack packet %lun", ack);
  338. if (linux_.icsk_ca_ops) {
  339. //This has to be done before the first call to linux_.icsk_ca_ops.
  340. paramManager.load_local();
  341. //After this call, all return must be done after a paramManager.restore_default, or save_to_linux (which inclues restore_default).
  342. };
  344. if (hdr_flags::access(pkt)->ecnecho() && ecn_ && (ack>1)) {
  345. //ecn(tcph->seqno());
  346. flag |= FLAG_ECE; //ECN
  347. }
  349. prior_in_flight = packets_in_flight();
  351. if (ack>prior_snd_una) {
  352. linux_.bytes_acked += (ack - prior_snd_una)*linux_.mss_cache;
  353. flag |= (FLAG_DATA_ACKED);
  354. };
  356. flag |= ack_processing(pkt, flag);
  357. DEBUG(5, "ack_processed prior_snd_una=%lu ack=%lun", prior_snd_una, ack);
  359. if ((tcph->sa_length()> 0) || (FLAG_DATA_ACKED && (!scb_->IsEmpty()))) {
  360. flag |= scb_->UpdateScoreBoard(highest_ack_, tcph);
  361. };
  362. DEBUG(5, "sack processed sack len=%d n", tcph->sa_length());
  364. time_processing(pkt, flag, &seq_rtt);
  365. DEBUG(5, "time processedn");
  368. if (linux_.icsk_ca_ops) {
  369. if ((!initialized_)) {
  370. if  (linux_.icsk_ca_ops->init)
  371. linux_.icsk_ca_ops->init(&linux_);
  372. initialized_ = true;
  373. }
  374. if ((flag & FLAG_NOT_DUP) && (linux_.icsk_ca_ops->pkts_acked)){
  375. ktime_t last_ackt;
  376. if ((flag & FLAG_UNSURE_TSTAMP) || (!bugfix_ts_)) {
  377. last_ackt = 0;
  378. } else {
  379.         double then = tss[tcph->seqno() % tss_size_];
  380. last_ackt = (s64)trunc(then*1000000000);
  381. };
  382. linux_.icsk_ca_ops->pkts_acked(sk, ack - prior_snd_una, last_ackt);
  383. }
  385. if ((linux_.icsk_ca_state==TCP_CA_Open)&& (!(flag&FLAG_CA_ALERT)) && (flag&FLAG_NOT_DUP)) {
  386. tcp_ca_event(CA_EVENT_FAST_ACK);
  387. }
  388. else {
  389. tcp_ca_event(CA_EVENT_SLOW_ACK);
  390. }
  391. }
  393. //  if (tp->frto_counter) tcp_process_frto(sk, prior_snd_una); //We haven't done FRTO yet.
  395. #define tcp_ack_is_dubious(flag) (!(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) || linux_.icsk_ca_state != TCP_CA_Open)
  397. #define tcp_may_raise_cwnd(flag) (!(flag & FLAG_ECE) || linux_.snd_cwnd < linux_.snd_ssthresh) && 
  398. !((1 << linux_.icsk_ca_state) & (TCPF_CA_Recovery | TCPF_CA_CWR))
  400. #define tcp_cong_avoid(ack, rtt, in_flight, good) 
  401. {
  402. if (linux_.icsk_ca_ops) {
  403. linux_.icsk_ca_ops->cong_avoid(sk, ack*linux_.mss_cache, rtt, in_flight, good);
  404. } else {
  405. opencwnd();
  406. load_to_linux();
  407. }
  408. touch_cwnd();
  409. }
  410. DEBUG(5, "Event processedn");
  411. if (tcp_ack_is_dubious(flag)){
  412. if ((flag & FLAG_DATA_ACKED) && tcp_may_raise_cwnd(flag))
  413. tcp_cong_avoid(ack, seq_rtt, prior_in_flight, 0);
  414. DEBUG(5, "dubious track cc finishedn");
  415. tcp_fastretrans_alert(flag);
  416. } else {
  417. if ((flag & FLAG_DATA_ACKED)) {
  418. prev_highest_ack_ = highest_ack_ ;
  419. tcp_cong_avoid(ack, seq_rtt, prior_in_flight, 1);
  420. }
  421. };
  422. DEBUG(5, "cc all finishedn");
  424. if (linux_.icsk_ca_ops) {
  425. save_from_linux();
  426. paramManager.restore_default();
  427. };
  428. send_much(FALSE, 0, maxburst_); //anytime we can do send_much by checking it.
  429. DEBUG(5, "data sentn");
  430. Packet::free(pkt);
  432. #ifdef notyet
  433. if (trace_)
  434. plot();
  435. #endif
  436. }
  438. //////////////////////////////  Congestion Control part ////////////////////////////
  439. void LinuxTcpAgent::touch_cwnd() {
  440. linux_.snd_cwnd_stamp = tcp_time_stamp; /* we touch the congestion window in this function */
  441. }
  442. void LinuxTcpAgent::tcp_moderate_cwnd()
  443. {
  444. linux_.snd_cwnd = min((int)linux_.snd_cwnd, packets_in_flight()+ tcp_max_burst); //max
  445. touch_cwnd();
  446. }
  448. void LinuxTcpAgent::tcp_fastretrans_alert(unsigned char flag)
  449. {
  450. struct inet_connection_sock *icsk = &linux_;
  453. // We don't have tcp_mark_head_lost yet
  455. /* E. Check state exit conditions. State can be terminated
  456.  *    when high_seq is ACKed. */
  457. if (icsk->icsk_ca_state == TCP_CA_Open) {
  458. //no need to exit unless frto.
  459. } else {
  460. if (highest_ack_ >= recover_) {
  461. DEBUG(5,"clear scoread boardn");
  462. scb_->ClearScoreBoard();
  463. if (linux_.icsk_ca_ops == NULL) load_to_linux();
  464. if (linux_.snd_cwnd < linux_.snd_ssthresh)
  465. {
  466. linux_.snd_cwnd = linux_.snd_ssthresh;
  467. tcp_moderate_cwnd();
  468. }
  469. tcp_set_ca_state(TCP_CA_Open);
  470. next_pkts_in_flight_ = 0; //stop rate halving
  471. return;
  472. }
  473. }
  475. DEBUG(5, "before step F: %dn", linux_.icsk_ca_state);
  476. /* F. Process state. */
  477. switch (linux_.icsk_ca_state) {
  478. case TCP_CA_Recovery: break;
  479. case TCP_CA_Loss:
  480. //let it through
  481. default:
  482. //TCP_CA_Open and have loss or ECE
  483. if (flag&(FLAG_DATA_LOST | FLAG_ECE)) {
  484. recover_ = maxseq_;
  485. last_cwnd_action_ = CWND_ACTION_DUPACK;
  486.         touch_cwnd();
  487. next_pkts_in_flight_ = linux_.snd_cwnd; //we do rate halving
  488.         if (linux_.icsk_ca_ops==NULL) {
  489.                  slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
  490. load_to_linux();
  491.          } else {
  492. //ok this is the linux part
  493. DEBUG(5, "check ssthreshn");
  494. linux_.snd_ssthresh = icsk->icsk_ca_ops->ssthresh(&linux_);
  495. linux_.snd_cwnd_cnt = 0;
  496. linux_.bytes_acked = 0;
  497. DEBUG(5, "check min_cwnd %pn", icsk->icsk_ca_ops->min_cwnd);
  498. if (icsk->icsk_ca_ops->min_cwnd)
  499. linux_.snd_cwnd = icsk->icsk_ca_ops->min_cwnd(&linux_);
  500. else
  501. linux_.snd_cwnd = linux_.snd_ssthresh;
  502. ncwndcuts_++;
  503. cong_action_ = TRUE;
  504. // Linux uses a CWR process to halve rate, we have a simpler one.
  505. }
  506. if (flag & FLAG_ECE) ++necnresponses_;
  507. tcp_set_ca_state(TCP_CA_Recovery);
  508. }
  509. }
  510. }
  512. void LinuxTcpAgent::enter_loss() 
  513. {
  514. paramManager.load_local();
  515. touch_cwnd();
  516. if (linux_.icsk_ca_ops==NULL) {
  517. slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART);
  518. load_to_linux();
  519. } else {
  521. //ok this is the linux part
  523. // if (icsk->icsk_ca_state <= TCP_CA_Disorder || tp->snd_una == tp->high_seq ||
  524. //     (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
  525. //tp->prior_ssthresh = tcp_current_ssthresh(sk);
  526. // icsk->icsk_retransmits: this is the # of unrecovered loss. in our case, all the loss are unrecovered.
  527. // if (linux_icsk_ca_state <= TCP_CA_Disorder || (highest_ack_+1) == recover_ || linux_icsk_ca_state== TCP_CA_LOSS) {
  529. linux_.snd_ssthresh = linux_.icsk_ca_ops->ssthresh(&linux_);
  530. tcp_ca_event(CA_EVENT_LOSS);
  531. linux_.snd_cwnd = 1;
  532. linux_.snd_cwnd_cnt = 0;
  533. linux_.bytes_acked = 0;
  534. //We don't have undo yet, otherwise, we should have:
  535. //tp->undo_marker = tp->snd_una;
  537. //We don't have reording yet, otherwise, we should have:
  538. //tp->reordering = min_t(unsigned int, tp->reordering, sysctl_tcp_reordering);
  540. //tp->high_seq = tp->snd_nxt;
  542. //We don't have ECN yet, otherwise, we should have: 
  543. //TCP_ECN_queue_cwr(tp);
  545. ncwndcuts_++;
  546. cong_action_ = TRUE;
  547. }
  548. recover_ = maxseq_;
  549. tcp_set_ca_state(TCP_CA_Loss); 
  550. //scb_->ClearScoreBoard();
  551. scb_->MarkLoss(highest_ack_+1, t_seqno_);
  552. //In Linux, we don't clear scoreboard in timeout, unless it's SACK Renege. We don't consider SACK Renege here.
  553. paramManager.restore_default();
  555. }
  557. void LinuxTcpAgent::timeout(int tno)
  558. {
  559. if (tno == TCP_TIMER_RTX) {
  560. if (highest_ack_ == maxseq_ && !slow_start_restart_) {
  561. /*
  562.  * TCP option:
  563.  * If no outstanding data, then don't do anything.
  564.  */
  565. return;
  566. };
  567. last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  568. /* if there is no outstanding data, don't cut down ssthresh_ */
  569. if (highest_ack_ == maxseq_ && restart_bugfix_) {
  570. if (linux_.icsk_ca_ops) save_from_linux();
  571. slowdown(CLOSE_CWND_INIT);
  572. load_to_linux();
  573. } else {
  574. // close down to 1 segment
  575. enter_loss();
  576. ++nrexmit_;
  577. };
  578. /* if there is no outstanding data, don't back off rtx timer */
  579. if (highest_ack_ == maxseq_)
  580. reset_rtx_timer(TCP_REASON_TIMEOUT,0);
  581. else
  582. reset_rtx_timer(TCP_REASON_TIMEOUT,1);
  583. next_pkts_in_flight_ = 0;
  584. linux_.bytes_acked = 0;
  585. save_from_linux();
  586. send_much(0, TCP_REASON_TIMEOUT);
  587. } else {
  588. /* we do not know what it is */
  589. if (linux_.icsk_ca_ops) save_from_linux();
  590. TcpAgent::timeout(tno);
  591. load_to_linux();
  592. };
  593. }
  596. ///////////////////////////   Sending control part ///////////////////
  597. int LinuxTcpAgent::packets_in_flight()
  598. {
  599. return (scb_->packets_in_flight(highest_ack_+1, t_seqno_));
  600. }
  602. bool LinuxTcpAgent::is_congestion() 
  603. {
  604. return ( packets_in_flight() >= (int)linux_.snd_cwnd);
  605. }
  607. void LinuxTcpAgent::send_much(int force, int reason, int maxburst)
  608. {
  609. register int found, npacket = 0;
  610. send_idle_helper();
  612. int win = window();
  613. int xmit_seqno;
  615. if (!force && delsnd_timer_.status() == TIMER_PENDING)
  616. return;
  617. /* 
  618.  * If TCP_TIMER_BURSTSND is pending, cancel it. The timer is
  619.  * set again, if necessary, after the maxburst pakts have been
  620.  * sent out.
  621. */
  622. if (burstsnd_timer_.status() == TIMER_PENDING)
  623. burstsnd_timer_.cancel();
  625. found = 1;
  626. /*
  627. * as long as the pipe is open and there is app data to send...
  628. */
  629. next_pkts_in_flight_ = min(next_pkts_in_flight_, packets_in_flight()+1);
  631. while ( packets_in_flight() < max(win, next_pkts_in_flight_) ) {
  632. if (overhead_ == 0 || force) {
  633. found = 0;
  634. xmit_seqno = scb_->GetNextRetran ();
  636. if (xmit_seqno == -1) {  // no retransmissions to send
  637. /* 
  638.  * if there is no more application data to send,
  639.  * do nothing
  640.  */
  641. if (t_seqno_ >= curseq_) 
  642. return;
  643. found = 1;
  644. xmit_seqno = t_seqno_++;
  645. } else {
  646. found = 1;
  647. DEBUG(5, "%lf (%p) : Retran %dn", Scheduler::instance().clock(), this, xmit_seqno);
  648. scb_->MarkRetran (xmit_seqno, t_seqno_);
  649. win = window();
  650. }
  651. if (found) {
  652. output(xmit_seqno, reason);
  653. next_pkts_in_flight_ = min( next_pkts_in_flight_, max(packets_in_flight()-1,1));
  654. if (t_seqno_ <= xmit_seqno) {
  655. printf("Hit a strange case 2.n");
  656. t_seqno_ = xmit_seqno + 1;
  657. }
  658. linux_.snd_nxt = t_seqno_*linux_.mss_cache;
  659. npacket++;
  660. }
  661. } else if (!(delsnd_timer_.status() == TIMER_PENDING)) {
  662. /*
  663.  * Set a delayed send timeout.
  664.  */
  665. delsnd_timer_.resched(Random::uniform(overhead_));
  666. return;
  667. }
  668. if (maxburst && npacket >= maxburst)
  669. break;
  670. } /* while */
  672. /* call helper function */
  673. send_helper(maxburst);
  674. }
  677. ////////////////////   Linux Module control part /////////////////////////////
  678. void LinuxTcpAgent::load_to_linux()
  679. {
  681. //TODO
  682. linux_.snd_ssthresh = (int)ssthresh_;
  684. if ((next_pkts_in_flight_ > (int)linux_.snd_cwnd) && (cwnd_ >= (int)linux_.snd_cwnd)) {
  685. //We are in the process of rate-halving and the traditional ns-2 does not ask for further reduction
  686. next_pkts_in_flight_ = (int)(trunc(cwnd_));
  687. } else {
  688. //We are not in the process of rate-halving -- safe to load
  689. linux_.snd_cwnd = (int)(trunc(cwnd_));
  690. //linux_.snd_cwnd_cnt = (int) ((cwnd_ - (double)linux_.snd_cwnd)* (double)linux_.snd_cwnd);
  691. }
  693. //read only:
  694. linux_.snd_cwnd_clamp = (int) wnd_;
  696. //read only for linux
  698. // linux_.snd_nxt  this variable is directly controlled by ack_processing() and send_much()
  699. // linux_.snd_una  this variable is directly controlled by ack_processing()
  700. // linux_.srtt     this variable is directly controlled by rtt_update()
  701. //      snd_cwnd_stamp  this variable is directly controlled by touch_cwnd()
  702. // linux_.rx_opt.rcv_tsecr is directly controled in ack_processing()
  703. // linux_.rx_opt.saw_tstamp is directly controled in ack_processing()
  704. // snd_cwnd_stamp this variable is directly controled by touch_cwnd()
  706. //remark:
  707. //snd_una == (highest_ack+1)*mss_cache
  708. //snd_nxt == (t_seqno)*mss_cache
  710. };
  712. void LinuxTcpAgent::save_from_linux()
  713. {
  715. //TODO
  716. if (next_pkts_in_flight_ > (int)linux_.snd_cwnd) 
  717. cwnd_ = next_pkts_in_flight_; 
  718. else
  719. cwnd_ = linux_.snd_cwnd;
  720. // + min(((double)linux_.snd_cwnd_cnt/(double)linux_.snd_cwnd),1);
  722. ssthresh_ = linux_.snd_ssthresh;
  723. // for legacy variables:
  724. last_ack_ = highest_ack_;
  726. };
  728. void LinuxTcpAgent::load_to_linux_once() {
  729. linux_.snd_cwnd_clamp = (long unsigned) round(wnd_);
  730. linux_.snd_ssthresh = linux_.snd_cwnd_clamp;
  731. linux_.mss_cache = size_;
  732. }
  734. char LinuxTcpAgent::install_congestion_control(const char* name)
  735. {
  736. struct tcp_congestion_ops* newops = cong_ops_manager.get_ops(name);
  737. if (newops) {
  738. if (linux_.icsk_ca_ops!=newops) {
  739. //release any existing congestion control algorithm before install
  740.                  if (linux_.icsk_ca_ops !=NULL ) {
  741. if (linux_.icsk_ca_ops->release) 
  742. linux_.icsk_ca_ops->release(&linux_);
  743. save_from_linux();
  744. } else {
  745. load_to_linux_once();
  746. load_to_linux(); //it was controlled by NS2, load to Linux
  747. tcp_tick_ = 1.0/(double)JIFFY_RATIO;
  748. }
  749. linux_.icsk_ca_ops = newops;
  751. if ((initialized_) && (newops->init)) {
  752. //if the algorithm is changed in the middle, we need to intialize the module
  753. newops->init(&linux_);
  754. }
  756. if ((linux_.icsk_ca_ops->flags & TCP_CONG_RTT_STAMP)  || (linux_.icsk_ca_ops->rtt_sample)) {
  757. bugfix_ts_=1;
  758. // if rtt_sample exists, we must turn on the sender-side timestamp record to provide accurate rtt in microsecond.
  759. }
  761. save_from_linux();
  762. }
  763. return TRUE;
  764. } else {
  765. return FALSE;
  766. }
  767. };
  769. void LinuxTcpAgent::remove_congestion_control()
  770. {
  771. if (linux_.icsk_ca_ops != NULL) {
  772. if (linux_.icsk_ca_ops->release)
  773. linux_.icsk_ca_ops->release(&linux_);
  774. save_from_linux();
  775. linux_.icsk_ca_ops = NULL;
  776. }
  777. };
  779. int LinuxTcpAgent::command(int argc, const char*const* argv) 
  780. {
  781. if ((argc>=3) && (strcmp(argv[1], "select_ca")==0)) {
  782. printf("%s %s %sn", argv[0], argv[1], argv[2]);
  783. if (install_congestion_control(argv[2])==FALSE) {
  784. printf("Error: do not find %s as a congestion control algorithmn", argv[2]);
  785. cong_ops_manager.dump();
  786. }
  787. return (TCL_OK);
  788. };
  789. if ((argc>=5) && (strcmp(argv[1], "set_ca_param")==0)) {
  790. printf("%s %s %s %s %sn", argv[0], argv[1], argv[2], argv[3], argv[4]);
  791. if (!paramManager.set_param(argv[2], argv[3], atoi(argv[4]))) {
  792. printf("Error: do not find %s as a parameter for congestion control algorithm %sn", argv[3], argv[2]);
  793. };
  794. return (TCL_OK);
  795. };
  796. if ((argc>=4) && (strcmp(argv[1], "get_ca_param")==0)) {
  797. printf("%s %s %s %sn", argv[0], argv[1], argv[2], argv[3]);
  798. int res;
  799. if (!paramManager.get_param(argv[2], argv[3], &res)) {
  800. printf("Error: do not find %s as a parameter for congestion control algorithm %sn", argv[3], argv[2]);
  801. } else {
  802. printf("tcp_%s.%s = %dn", argv[2], argv[3], res);
  803. };
  804. return (TCL_OK);
  805. };
  806. if ((argc>=5) && (strcmp(argv[1], "set_ca_default_param")==0)) {
  807. printf("%s %s %s %s %sn", argv[0], argv[1], argv[2], argv[3], argv[4]);
  808. if (!paramManager.set_default_param(argv[2], argv[3], atoi(argv[4]))) {
  809. printf("Error: do not find %s as a parameter for congestion control algorithm %sn", argv[3], argv[2]);
  810. };
  811. return (TCL_OK);
  812. };
  813. if ((argc>=4) && (strcmp(argv[1], "get_ca_default_param")==0)) {
  814. printf("%s %s %s %sn", argv[0], argv[1], argv[2], argv[3]);
  815. int res;
  816. if (!paramManager.get_default_param(argv[2], argv[3], &res)) {
  817. printf("Error: do not find %s as a parameter for congestion control algorithm %sn", argv[3], argv[2]);
  818. } else {
  819. printf("tcp_%s.%s = %dn", argv[2], argv[3], res);
  820. };
  821. return (TCL_OK);
  822. };
  823. if ((argc==3) && (strcmp(argv[1], "get_ca_param")==0)) {
  824. printf("%s %s %sn", argv[0], argv[1], argv[2]);
  825. if (!paramManager.query_param(argv[2])) {
  826. printf("Error: %s is not a congestion control algorithm or has no parametern", argv[2]);
  827. };
  828. return (TCL_OK);
  829. };
  830. return (TcpAgent::command(argc, argv));
  832. }
  834. void LinuxTcpAgent::plot()
  835. {
  836. #ifdef notyet
  837. double t = Scheduler::instance().clock();
  838. sprintf(trace_->buffer(), "t %g %d rtt %gn", 
  839. t, class_, t_rtt_ * tcp_tick_);
  840. trace_->dump();
  841. sprintf(trace_->buffer(), "t %g %d dev %gn", 
  842. t, class_, t_rttvar_ * tcp_tick_);
  843. trace_->dump();
  844. sprintf(trace_->buffer(), "t %g %d win %fn", t, class_, cwnd_);
  845. trace_->dump();
  846. sprintf(trace_->buffer(), "t %g %d bck %dn", t, class_, t_backoff_);
  847. trace_->dump();
  848. #endif
  849. }
  852. /* Implementation of LinuxParamManager */
  853. struct cc_list* LinuxParamManager::find_cc_by_proto(const char* proto) {
  854. struct cc_list* p = cc_list_head;
  855. char proto_name[100];
  856. snprintf(proto_name, 100, "tcp_%s.c", proto);
  857. while (p!=NULL && (strcmp(p->proto, proto_name)!=0)) p=p->next;
  858. return p;
  859. };
  861. struct cc_param_list* LinuxParamManager::find_param_by_proto_name(const char* proto, const char* name) {
  862. struct cc_list* p = find_cc_by_proto(proto);
  863. if (!p) return NULL;
  864. struct cc_param_list* q = p->param_head;
  865. while (q!=NULL && ((strcmp(q->name, name)!=0)||(strcmp(q->type, "int")!=0))) q=q->next;
  866. return q;
  867. };
  869. bool LinuxParamManager::set_default_param(const char* proto, const char* param, const int value) {
  870. struct cc_param_list* p = find_param_by_proto_name(proto, param);
  871. if (!p) return false;
  872. (*(int*)p->ptr) = value;
  873. return true;
  874. };
  876. bool LinuxParamManager::set_param(const char* proto, const char* param, const int value) {
  877. struct cc_param_list* p = find_param_by_proto_name(proto, param);
  878. if (!p) return false;
  879. localValues.set_param((int*)p->ptr, value);
  880. return true;
  881. };
  883. bool LinuxParamManager::get_default_param(const char* proto, const char* param, int* valuep) {
  884. struct cc_param_list* p = find_param_by_proto_name(proto, param);
  885. if (!p) return false;
  886. *valuep = *((int*)(p->ptr));
  887. return true;
  888. };
  890. bool LinuxParamManager::get_param(const char* proto, const char* param, int* valuep) {
  891. struct cc_param_list* p = find_param_by_proto_name(proto, param);
  892. if (!p) return false;
  893. if (localValues.get_param((int*)p->ptr, valuep)) return true;
  894. *valuep = *((int*)(p->ptr));
  895. return true;
  896. };
  897. bool LinuxParamManager::query_param(const char* proto) {
  898. struct cc_list* p = find_cc_by_proto(proto);
  899. if (!p) {
  900. printf("%s has no parameter registeredn", proto);
  901. return false;
  902. };
  903. printf("Parameter list for %s:n", proto);
  904. struct cc_param_list* q = p->param_head;
  905. while (q != NULL) {
  906. printf(" %s = %d (%s)n", q->name, *((int*)q->ptr), q->description);
  907. q = q->next;
  908. }; 
  909. return true;
  910. };
  911. /** Get a local value for a TCP */
  912. bool ParamList::get_param(int* address, int* valuep) {
  913. struct paramNode *p = head;
  914. while (p && (p->addr != address)) p = p->next;
  915. if (p) {
  916. *valuep = p->value;
  917. return true;
  918. };
  919. return false;
  920. };
  922. /** Set a local value for a TCP */
  923. void ParamList::set_param(int* address, int value) {
  924. struct paramNode *p = head;
  925. while ((p) && (p->addr != address)) {
  926. p = p->next;
  927. };
  928. if (p) {
  929. //we find one.
  930. p->value = value;
  931. return;
  932. };
  933. //Cannot find any
  934. //Create a new entry
  935. p = new struct paramNode;
  936. p->addr = address; 
  937. p->value = value;
  938. p->default_value = *address;
  939. p->next = head;
  940. head = p;
  941. };
  943. /** Refresh all the values in the list */
  944. void ParamList::refresh_default() {
  945. struct paramNode *p = head;
  946. while (p) {
  947. p->default_value = *(p->addr);
  948. p = p->next;
  949. };
  950. };
  952. void ParamList::restore_default() {
  953. struct paramNode *p = head;
  954. while (p) {
  955. p->value = *(p->addr);
  956. *(p->addr) = p->default_value;
  957. p = p->next;
  958. };
  959. };
  961. void ParamList::load_local() {
  962. struct paramNode *p = head;
  963. while (p) {
  964. p->default_value = *(p->addr);
  965. *(p->addr) = p->value;
  966. p = p->next;
  967. };
  968. };
  970. ParamList::~ParamList() {
  971. while (head) {
  972. struct paramNode *p = head;
  973. head = head->next;
  974. delete p;
  975. };
  976. };