Changeset a1a101d in mainline for uspace/srv/net/tcp


Ignore:
Timestamp:
2012-08-17T16:58:51Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
bc0ccab
Parents:
920d0fc
Message:

Get rid of log_log_msg()

All calls to log_msg(LVL_*) were rewritten to
log_msg(LOG_DEFAULT, LVL_*).

Location:
uspace/srv/net/tcp
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/tcp/conn.c

    r920d0fc ra1a101d  
    164164static void tcp_conn_free(tcp_conn_t *conn)
    165165{
    166         log_msg(LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
     166        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
    167167        tcp_tqueue_fini(&conn->retransmit);
    168168
    … …  
    184184void tcp_conn_addref(tcp_conn_t *conn)
    185185{
    186         log_msg(LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn);
     186        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn);
    187187        atomic_inc(&conn->refcnt);
    188188}
    … …  
    196196void tcp_conn_delref(tcp_conn_t *conn)
    197197{
    198         log_msg(LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn);
     198        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn);
    199199
    200200        if (atomic_predec(&conn->refcnt) == 0)
    … …  
    211211void tcp_conn_delete(tcp_conn_t *conn)
    212212{
    213         log_msg(LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn);
     213        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn);
    214214
    215215        assert(conn->deleted == false);
    … …  
    245245        tcp_cstate_t old_state;
    246246
    247         log_msg(LVL_DEBUG, "tcp_conn_state_set(%p)", conn);
     247        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set(%p)", conn);
    248248
    249249        old_state = conn->cstate;
    … …  
    253253        /* Run user callback function */
    254254        if (conn->cstate_cb != NULL) {
    255                 log_msg(LVL_DEBUG, "tcp_conn_state_set() - run user CB");
     255                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - run user CB");
    256256                conn->cstate_cb(conn, conn->cstate_cb_arg);
    257257        } else {
    258                 log_msg(LVL_DEBUG, "tcp_conn_state_set() - no user CB");
     258                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - no user CB");
    259259        }
    260260
    … …  
    293293        case st_syn_received:
    294294        case st_established:
    295                 log_msg(LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name);
     295                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name);
    296296                tcp_conn_state_set(conn, st_fin_wait_1);
    297297                break;
    298298        case st_close_wait:
    299                 log_msg(LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name);
     299                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name);
    300300                tcp_conn_state_set(conn, st_last_ack);
    301301                break;
    302302        default:
    303                 log_msg(LVL_ERROR, "%s: Connection state %d", conn->name,
     303                log_msg(LOG_DEFAULT, LVL_ERROR, "%s: Connection state %d", conn->name,
    304304                    conn->cstate);
    305305                assert(false);
    … …  
    312312static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
    313313{
    314         log_msg(LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
     314        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    315315            sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    316316
    … …  
    323323                return false;
    324324
    325         log_msg(LVL_DEBUG2, " -> match");
     325        log_msg(LOG_DEFAULT, LVL_DEBUG2, " -> match");
    326326
    327327        return true;
    … …  
    331331static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern)
    332332{
    333         log_msg(LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern);
     333        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern);
    334334
    335335        if (!tcp_socket_match(&sp->local, &pattern->local))
    … …  
    353353tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp)
    354354{
    355         log_msg(LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
     355        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356356
    357357        fibril_mutex_lock(&conn_list_lock);
    … …  
    360360                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    361361                tcp_sockpair_t *csp = &conn->ident;
    362                 log_msg(LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
     362                log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
    363363                    csp->foreign.addr.ipv4, csp->foreign.port,
    364364                    csp->local.addr.ipv4, csp->local.port);
    … …  
    380380static void tcp_conn_reset(tcp_conn_t *conn)
    381381{
    382         log_msg(LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);
     382        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);
    383383        tcp_conn_state_set(conn, st_closed);
    384384        conn->reset = true;
    … …  
    398398{
    399399        /* TODO */
    400         log_msg(LVL_DEBUG, "%s: tcp_reset_signal()", conn->name);
     400        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_reset_signal()", conn->name);
    401401}
    402402
    … …  
    422422                return true;
    423423        case st_closed:
    424                 log_msg(LVL_WARN, "state=%d", (int) conn->cstate);
     424                log_msg(LOG_DEFAULT, LVL_WARN, "state=%d", (int) conn->cstate);
    425425                assert(false);
    426426        }
    … …  
    436436static void tcp_conn_sa_listen(tcp_conn_t *conn, tcp_segment_t *seg)
    437437{
    438         log_msg(LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg);
     438        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg);
    439439
    440440        if ((seg->ctrl & CTL_RST) != 0) {
    441                 log_msg(LVL_DEBUG, "Ignoring incoming RST.");
     441                log_msg(LOG_DEFAULT, LVL_DEBUG, "Ignoring incoming RST.");
    442442                return;
    443443        }
    444444
    445445        if ((seg->ctrl & CTL_ACK) != 0) {
    446                 log_msg(LVL_DEBUG, "Incoming ACK, send acceptable RST.");
     446                log_msg(LOG_DEFAULT, LVL_DEBUG, "Incoming ACK, send acceptable RST.");
    447447                tcp_reply_rst(&conn->ident, seg);
    448448                return;
    … …  
    450450
    451451        if ((seg->ctrl & CTL_SYN) == 0) {
    452                 log_msg(LVL_DEBUG, "SYN not present. Ignoring segment.");
    453                 return;
    454         }
    455 
    456         log_msg(LVL_DEBUG, "Got SYN, sending SYN, ACK.");
     452                log_msg(LOG_DEFAULT, LVL_DEBUG, "SYN not present. Ignoring segment.");
     453                return;
     454        }
     455
     456        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got SYN, sending SYN, ACK.");
    457457
    458458        conn->rcv_nxt = seg->seq + 1;
    … …  
    460460
    461461
    462         log_msg(LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt);
     462        log_msg(LOG_DEFAULT, LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt);
    463463
    464464        if (seg->len > 1)
    465                 log_msg(LVL_WARN, "SYN combined with data, ignoring data.");
     465                log_msg(LOG_DEFAULT, LVL_WARN, "SYN combined with data, ignoring data.");
    466466
    467467        /* XXX select ISS */
    … …  
    493493static void tcp_conn_sa_syn_sent(tcp_conn_t *conn, tcp_segment_t *seg)
    494494{
    495         log_msg(LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg);
     495        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg);
    496496
    497497        if ((seg->ctrl & CTL_ACK) != 0) {
    498                 log_msg(LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u",
     498                log_msg(LOG_DEFAULT, LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u",
    499499                    conn->snd_una, seg->ack, conn->snd_nxt);
    500500                if (!seq_no_ack_acceptable(conn, seg->ack)) {
    501501                        if ((seg->ctrl & CTL_RST) == 0) {
    502                                 log_msg(LVL_WARN, "ACK not acceptable, send RST");
     502                                log_msg(LOG_DEFAULT, LVL_WARN, "ACK not acceptable, send RST");
    503503                                tcp_reply_rst(&conn->ident, seg);
    504504                        } else {
    505                                 log_msg(LVL_WARN, "RST,ACK not acceptable, drop");
     505                                log_msg(LOG_DEFAULT, LVL_WARN, "RST,ACK not acceptable, drop");
    506506                        }
    507507                        return;
    … …  
    512512                /* If we get here, we have either an acceptable ACK or no ACK */
    513513                if ((seg->ctrl & CTL_ACK) != 0) {
    514                         log_msg(LVL_DEBUG, "%s: Connection reset. -> Closed",
     514                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Connection reset. -> Closed",
    515515                            conn->name);
    516516                        /* Reset connection */
    … …  
    518518                        return;
    519519                } else {
    520                         log_msg(LVL_DEBUG, "%s: RST without ACK, drop",
     520                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: RST without ACK, drop",
    521521                            conn->name);
    522522                        return;
    … …  
    527527
    528528        if ((seg->ctrl & CTL_SYN) == 0) {
    529                 log_msg(LVL_DEBUG, "No SYN bit, ignoring segment.");
     529                log_msg(LOG_DEFAULT, LVL_DEBUG, "No SYN bit, ignoring segment.");
    530530                return;
    531531        }
    … …  
    544544        }
    545545
    546         log_msg(LVL_DEBUG, "Sent SYN, got SYN.");
     546        log_msg(LOG_DEFAULT, LVL_DEBUG, "Sent SYN, got SYN.");
    547547
    548548        /*
    … …  
    551551         * will always be accepted as new window setting.
    552552         */
    553         log_msg(LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", "
     553        log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", "
    554554            "SND.WL2 = %" PRIu32, seg->wnd, seg->seq, seg->seq);
    555555        conn->snd_wnd = seg->wnd;
    … …  
    558558
    559559        if (seq_no_syn_acked(conn)) {
    560                 log_msg(LVL_DEBUG, "%s: syn acked -> Established", conn->name);
     560                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: syn acked -> Established", conn->name);
    561561                tcp_conn_state_set(conn, st_established);
    562562                tcp_tqueue_ctrl_seg(conn, CTL_ACK /* XXX */);
    563563        } else {
    564                 log_msg(LVL_DEBUG, "%s: syn not acked -> Syn-Received",
     564                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: syn not acked -> Syn-Received",
    565565                    conn->name);
    566566                tcp_conn_state_set(conn, st_syn_received);
    … …  
    582582        tcp_segment_t *pseg;
    583583
    584         log_msg(LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg);
     584        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg);
    585585
    586586        /* Discard unacceptable segments ("old duplicates") */
    587587        if (!seq_no_segment_acceptable(conn, seg)) {
    588                 log_msg(LVL_DEBUG, "Replying ACK to unacceptable segment.");
     588                log_msg(LOG_DEFAULT, LVL_DEBUG, "Replying ACK to unacceptable segment.");
    589589                tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    590590                tcp_segment_delete(seg);
    … …  
    682682        assert(seq_no_in_rcv_wnd(conn, seg->seq));
    683683
    684         log_msg(LVL_WARN, "SYN is in receive window, should send reset. XXX");
     684        log_msg(LOG_DEFAULT, LVL_WARN, "SYN is in receive window, should send reset. XXX");
    685685
    686686        /*
    … …  
    705705        if (!seq_no_ack_acceptable(conn, seg->ack)) {
    706706                /* ACK is not acceptable, send RST. */
    707                 log_msg(LVL_WARN, "Segment ACK not acceptable, sending RST.");
     707                log_msg(LOG_DEFAULT, LVL_WARN, "Segment ACK not acceptable, sending RST.");
    708708                tcp_reply_rst(&conn->ident, seg);
    709709                tcp_segment_delete(seg);
    … …  
    711711        }
    712712
    713         log_msg(LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name);
     713        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name);
    714714
    715715        tcp_conn_state_set(conn, st_established);
    … …  
    730730static cproc_t tcp_conn_seg_proc_ack_est(tcp_conn_t *conn, tcp_segment_t *seg)
    731731{
    732         log_msg(LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg);
    733 
    734         log_msg(LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u",
     732        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg);
     733
     734        log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u",
    735735            (unsigned)seg->ack, (unsigned)conn->snd_una,
    736736            (unsigned)conn->snd_nxt);
    737737
    738738        if (!seq_no_ack_acceptable(conn, seg->ack)) {
    739                 log_msg(LVL_DEBUG, "ACK not acceptable.");
     739                log_msg(LOG_DEFAULT, LVL_DEBUG, "ACK not acceptable.");
    740740                if (!seq_no_ack_duplicate(conn, seg->ack)) {
    741                         log_msg(LVL_WARN, "Not acceptable, not duplicate. "
     741                        log_msg(LOG_DEFAULT, LVL_WARN, "Not acceptable, not duplicate. "
    742742                            "Send ACK and drop.");
    743743                        /* Not acceptable, not duplicate. Send ACK and drop. */
    … …  
    746746                        return cp_done;
    747747                } else {
    748                         log_msg(LVL_DEBUG, "Ignoring duplicate ACK.");
     748                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Ignoring duplicate ACK.");
    749749                }
    750750        } else {
    … …  
    758758                conn->snd_wl2 = seg->ack;
    759759
    760                 log_msg(LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32
     760                log_msg(LOG_DEFAULT, LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32
    761761                    ", SND.WL1=%" PRIu32 ", SND.WL2=%" PRIu32,
    762762                    conn->snd_wnd, conn->snd_wl1, conn->snd_wl2);
    … …  
    785785
    786786        if (conn->fin_is_acked) {
    787                 log_msg(LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name);
     787                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name);
    788788                tcp_conn_state_set(conn, st_fin_wait_2);
    789789        }
    … …  
    850850
    851851        if (conn->fin_is_acked) {
    852                 log_msg(LVL_DEBUG, "%s: FIN acked -> Closed", conn->name);
     852                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Closed", conn->name);
    853853                tcp_conn_remove(conn);
    854854                tcp_conn_state_set(conn, st_closed);
    … …  
    881881static cproc_t tcp_conn_seg_proc_ack(tcp_conn_t *conn, tcp_segment_t *seg)
    882882{
    883         log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)",
     883        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)",
    884884            conn->name, conn, seg);
    885885
    886886        if ((seg->ctrl & CTL_ACK) == 0) {
    887                 log_msg(LVL_WARN, "Segment has no ACK. Dropping.");
     887                log_msg(LOG_DEFAULT, LVL_WARN, "Segment has no ACK. Dropping.");
    888888                tcp_segment_delete(seg);
    889889                return cp_done;
    … …  
    940940        size_t xfer_size;
    941941
    942         log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)",
     942        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)",
    943943            conn->name, conn, seg);
    944944
    … …  
    982982        fibril_condvar_broadcast(&conn->rcv_buf_cv);
    983983
    984         log_msg(LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
     984        log_msg(LOG_DEFAULT, LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
    985985
    986986        /* Advance RCV.NXT */
    … …  
    998998                tcp_conn_trim_seg_to_wnd(conn, seg);
    999999        } else {
    1000                 log_msg(LVL_DEBUG, "%s: Nothing left in segment, dropping "
     1000                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Nothing left in segment, dropping "
    10011001                    "(xfer_size=%zu, SEG.LEN=%zu, seg->ctrl=%u)",
    10021002                    conn->name, xfer_size, seg->len, (unsigned)seg->ctrl);
    … …  
    10181018static cproc_t tcp_conn_seg_proc_fin(tcp_conn_t *conn, tcp_segment_t *seg)
    10191019{
    1020         log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)",
     1020        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)",
    10211021            conn->name, conn, seg);
    1022         log_msg(LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len,
     1022        log_msg(LOG_DEFAULT, LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len,
    10231023            (unsigned) seg->ctrl);
    10241024
    10251025        /* Only process FIN if no text is left in segment. */
    10261026        if (tcp_segment_text_size(seg) == 0 && (seg->ctrl & CTL_FIN) != 0) {
    1027                 log_msg(LVL_DEBUG, " - FIN found in segment.");
     1027                log_msg(LOG_DEFAULT, LVL_DEBUG, " - FIN found in segment.");
    10281028
    10291029                /* Send ACK */
    … …  
    10421042                case st_syn_received:
    10431043                case st_established:
    1044                         log_msg(LVL_DEBUG, "%s: FIN received -> Close-Wait",
     1044                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Close-Wait",
    10451045                            conn->name);
    10461046                        tcp_conn_state_set(conn, st_close_wait);
    10471047                        break;
    10481048                case st_fin_wait_1:
    1049                         log_msg(LVL_DEBUG, "%s: FIN received -> Closing",
     1049                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Closing",
    10501050                            conn->name);
    10511051                        tcp_conn_state_set(conn, st_closing);
    10521052                        break;
    10531053                case st_fin_wait_2:
    1054                         log_msg(LVL_DEBUG, "%s: FIN received -> Time-Wait",
     1054                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN received -> Time-Wait",
    10551055                            conn->name);
    10561056                        tcp_conn_state_set(conn, st_time_wait);
    … …  
    10911091static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg)
    10921092{
    1093         log_msg(LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg);
     1093        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg);
    10941094        tcp_segment_dump(seg);
    10951095
    … …  
    10971097        /* XXX Permit valid ACKs, URGs and RSTs */
    10981098/*      if (!seq_no_segment_acceptable(conn, seg)) {
    1099                 log_msg(LVL_WARN, "Segment not acceptable, dropping.");
     1099                log_msg(LOG_DEFAULT, LVL_WARN, "Segment not acceptable, dropping.");
    11001100                if ((seg->ctrl & CTL_RST) == 0) {
    11011101                        tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    … …  
    11311131         */
    11321132        if (seg->len > 0) {
    1133                 log_msg(LVL_DEBUG, "Re-insert segment %p. seg->len=%zu",
     1133                log_msg(LOG_DEFAULT, LVL_DEBUG, "Re-insert segment %p. seg->len=%zu",
    11341134                    seg, (size_t) seg->len);
    11351135                tcp_iqueue_insert_seg(&conn->incoming, seg);
    … …  
    11461146void tcp_conn_segment_arrived(tcp_conn_t *conn, tcp_segment_t *seg)
    11471147{
    1148         log_msg(LVL_DEBUG, "%c: tcp_conn_segment_arrived(%p)",
     1148        log_msg(LOG_DEFAULT, LVL_DEBUG, "%c: tcp_conn_segment_arrived(%p)",
    11491149            conn->name, seg);
    11501150
    … …  
    11651165                tcp_conn_sa_queue(conn, seg); break;
    11661166        case st_closed:
    1167                 log_msg(LVL_DEBUG, "state=%d", (int) conn->cstate);
     1167                log_msg(LOG_DEFAULT, LVL_DEBUG, "state=%d", (int) conn->cstate);
    11681168                assert(false);
    11691169        }
    … …  
    11781178        tcp_conn_t *conn = (tcp_conn_t *) arg;
    11791179
    1180         log_msg(LVL_DEBUG, "tw_timeout_func(%p)", conn);
     1180        log_msg(LOG_DEFAULT, LVL_DEBUG, "tw_timeout_func(%p)", conn);
    11811181
    11821182        fibril_mutex_lock(&conn->lock);
    11831183
    11841184        if (conn->cstate == st_closed) {
    1185                 log_msg(LVL_DEBUG, "Connection already closed.");
     1185                log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
    11861186                fibril_mutex_unlock(&conn->lock);
    11871187                tcp_conn_delref(conn);
    … …  
    11891189        }
    11901190
    1191         log_msg(LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name);
     1191        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name);
    11921192        tcp_conn_remove(conn);
    11931193        tcp_conn_state_set(conn, st_closed);
    … …  
    12401240void tcp_unexpected_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
    12411241{
    1242         log_msg(LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg);
     1242        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg);
    12431243
    12441244        if ((seg->ctrl & CTL_RST) == 0)
    … …  
    12681268        tcp_segment_t *rseg;
    12691269
    1270         log_msg(LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg);
     1270        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg);
    12711271
    12721272        rseg = tcp_segment_make_rst(seg);

  • uspace/srv/net/tcp/iqueue.c

    r920d0fc ra1a101d  
    6767        tcp_iqueue_entry_t *qe;
    6868        link_t *link;
    69         log_msg(LVL_DEBUG, "tcp_iqueue_insert_seg()");
     69        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_iqueue_insert_seg()");
    7070
    7171        iqe = calloc(1, sizeof(tcp_iqueue_entry_t));
    7272        if (iqe == NULL) {
    73                 log_msg(LVL_ERROR, "Failed allocating IQE.");
     73                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating IQE.");
    7474                return;
    7575        }
    … …  
    108108        link_t *link;
    109109
    110         log_msg(LVL_DEBUG, "tcp_get_ready_seg()");
     110        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_get_ready_seg()");
    111111
    112112        link = list_first(&iqueue->list);
    113113        if (link == NULL) {
    114                 log_msg(LVL_DEBUG, "iqueue is empty");
     114                log_msg(LOG_DEFAULT, LVL_DEBUG, "iqueue is empty");
    115115                return ENOENT;
    116116        }
    … …  
    119119
    120120        while (!seq_no_segment_acceptable(iqueue->conn, iqe->seg)) {
    121                 log_msg(LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%"
     121                log_msg(LOG_DEFAULT, LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%"
    122122                    PRIu32 ", RCV.NXT+RCV.WND=%" PRIu32 ", SEG.SEQ=%" PRIu32
    123123                    ", SEG.LEN=%" PRIu32 ")", iqueue->conn->rcv_nxt,
    … …  
    130130                link = list_first(&iqueue->list);
    131131                if (link == NULL) {
    132                         log_msg(LVL_DEBUG, "iqueue is empty");
     132                        log_msg(LOG_DEFAULT, LVL_DEBUG, "iqueue is empty");
    133133                        return ENOENT;
    134134                }
    … …  
    139139        /* Do not return segments that are not ready for processing */
    140140        if (!seq_no_segment_ready(iqueue->conn, iqe->seg)) {
    141                 log_msg(LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, "
     141                log_msg(LOG_DEFAULT, LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, "
    142142                    "RCV.NXT=%u, SEG.LEN=%u", iqe->seg->seq,
    143143                    iqueue->conn->rcv_nxt, iqe->seg->len);
    … …  
    145145        }
    146146
    147         log_msg(LVL_DEBUG, "Returning ready segment %p", iqe->seg);
     147        log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning ready segment %p", iqe->seg);
    148148        list_remove(&iqe->link);
    149149        *seg = iqe->seg;

  • uspace/srv/net/tcp/ncsim.c

    r920d0fc ra1a101d  
    7474        link_t *link;
    7575
    76         log_msg(LVL_DEBUG, "tcp_ncsim_bounce_seg()");
     76        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_bounce_seg()");
    7777        tcp_rqueue_bounce_seg(sp, seg);
    7878        return;
    … …  
    8080        if (0 /*random() % 4 == 3*/) {
    8181                /* Drop segment */
    82                 log_msg(LVL_ERROR, "NCSim dropping segment");
     82                log_msg(LOG_DEFAULT, LVL_ERROR, "NCSim dropping segment");
    8383                tcp_segment_delete(seg);
    8484                return;
    … …  
    8787        sqe = calloc(1, sizeof(tcp_squeue_entry_t));
    8888        if (sqe == NULL) {
    89                 log_msg(LVL_ERROR, "Failed allocating SQE.");
     89                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating SQE.");
    9090                return;
    9191        }
    … …  
    126126        int rc;
    127127
    128         log_msg(LVL_DEBUG, "tcp_ncsim_fibril()");
     128        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril()");
    129129
    130130
    … …  
    139139                        sqe = list_get_instance(link, tcp_squeue_entry_t, link);
    140140
    141                         log_msg(LVL_DEBUG, "NCSim - Sleep");
     141                        log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - Sleep");
    142142                        rc = fibril_condvar_wait_timeout(&sim_queue_cv,
    143143                            &sim_queue_lock, sqe->delay);
    … …  
    147147                fibril_mutex_unlock(&sim_queue_lock);
    148148
    149                 log_msg(LVL_DEBUG, "NCSim - End Sleep");
     149                log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - End Sleep");
    150150                tcp_rqueue_bounce_seg(&sqe->sp, sqe->seg);
    151151                free(sqe);
    … …  
    161161        fid_t fid;
    162162
    163         log_msg(LVL_DEBUG, "tcp_ncsim_fibril_start()");
     163        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_fibril_start()");
    164164
    165165        fid = fibril_create(tcp_ncsim_fibril, NULL);
    166166        if (fid == 0) {
    167                 log_msg(LVL_ERROR, "Failed creating ncsim fibril.");
     167                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating ncsim fibril.");
    168168                return;
    169169        }

  • uspace/srv/net/tcp/rqueue.c

    r920d0fc ra1a101d  
    7474        tcp_sockpair_t rident;
    7575
    76         log_msg(LVL_DEBUG, "tcp_rqueue_bounce_seg()");
     76        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_bounce_seg()");
    7777
    7878#ifdef BOUNCE_TRANSCODE
    … …  
    8181
    8282        if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
    83                 log_msg(LVL_WARN, "Not enough memory. Segment dropped.");
     83                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    8484                return;
    8585        }
    8686
    8787        if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) {
    88                 log_msg(LVL_WARN, "Not enough memory. Segment dropped.");
     88                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    8989                return;
    9090        }
    … …  
    112112{
    113113        tcp_rqueue_entry_t *rqe;
    114         log_msg(LVL_DEBUG, "tcp_rqueue_insert_seg()");
     114        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_insert_seg()");
    115115
    116116        tcp_segment_dump(seg);
    … …  
    118118        rqe = calloc(1, sizeof(tcp_rqueue_entry_t));
    119119        if (rqe == NULL) {
    120                 log_msg(LVL_ERROR, "Failed allocating RQE.");
     120                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed allocating RQE.");
    121121                return;
    122122        }
    … …  
    134134        tcp_rqueue_entry_t *rqe;
    135135
    136         log_msg(LVL_DEBUG, "tcp_rqueue_fibril()");
     136        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_fibril()");
    137137
    138138        while (true) {
    … …  
    152152        fid_t fid;
    153153
    154         log_msg(LVL_DEBUG, "tcp_rqueue_fibril_start()");
     154        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_fibril_start()");
    155155
    156156        fid = fibril_create(tcp_rqueue_fibril, NULL);
    157157        if (fid == 0) {
    158                 log_msg(LVL_ERROR, "Failed creating rqueue fibril.");
     158                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating rqueue fibril.");
    159159                return;
    160160        }

  • uspace/srv/net/tcp/segment.c

    r920d0fc ra1a101d  
    248248void tcp_segment_dump(tcp_segment_t *seg)
    249249{
    250         log_msg(LVL_DEBUG2, "Segment dump:");
    251         log_msg(LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl);
    252         log_msg(LVL_DEBUG2, " - seq = % " PRIu32, seg->seq);
    253         log_msg(LVL_DEBUG2, " - ack = % " PRIu32, seg->ack);
    254         log_msg(LVL_DEBUG2, " - len = % " PRIu32, seg->len);
    255         log_msg(LVL_DEBUG2, " - wnd = % " PRIu32, seg->wnd);
    256         log_msg(LVL_DEBUG2, " - up = % " PRIu32, seg->up);
     250        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Segment dump:");
     251        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl);
     252        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - seq = % " PRIu32, seg->seq);
     253        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ack = % " PRIu32, seg->ack);
     254        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - len = % " PRIu32, seg->len);
     255        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - wnd = % " PRIu32, seg->wnd);
     256        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - up = % " PRIu32, seg->up);
    257257}
    258258

  • uspace/srv/net/tcp/sock.c

    r920d0fc ra1a101d  
    9191static void tcp_sock_notify_data(socket_core_t *sock_core)
    9292{
    93         log_msg(LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
     93        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
    9494        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9595        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    … …  
    100100static void tcp_sock_notify_aconn(socket_core_t *lsock_core)
    101101{
    102         log_msg(LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
     102        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
    103103        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    104104        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    … …  
    111111        tcp_sockdata_t *sock;
    112112
    113         log_msg(LVL_DEBUG, "tcp_sock_create()");
     113        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_create()");
    114114        *rsock = NULL;
    115115
    … …  
    133133static void tcp_sock_uncreate(tcp_sockdata_t *sock)
    134134{
    135         log_msg(LVL_DEBUG, "tcp_sock_uncreate()");
     135        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_uncreate()");
    136136        free(sock);
    137137}
    … …  
    142142        int rc;
    143143
    144         log_msg(LVL_DEBUG, "tcp_sock_finish_setup()");
     144        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_finish_setup()");
    145145
    146146        sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
    … …  
    171171        ipc_call_t answer;
    172172
    173         log_msg(LVL_DEBUG, "tcp_sock_socket()");
     173        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_socket()");
    174174
    175175        rc = tcp_sock_create(client, &sock);
    … …  
    208208        tcp_sockdata_t *socket;
    209209
    210         log_msg(LVL_DEBUG, "tcp_sock_bind()");
    211         log_msg(LVL_DEBUG, " - async_data_write_accept");
     210        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()");
     211        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
    212212        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    213213        if (rc != EOK) {
    … …  
    216216        }
    217217
    218         log_msg(LVL_DEBUG, " - call socket_bind");
     218        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    219219        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    220220            addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    … …  
    225225        }
    226226
    227         log_msg(LVL_DEBUG, " - call socket_cores_find");
     227        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    228228        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    229229        if (sock_core != NULL) {
    … …  
    233233        }
    234234
    235         log_msg(LVL_DEBUG, " - success");
     235        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    236236        async_answer_0(callid, EOK);
    237237}
    … …  
    250250        int i;
    251251
    252         log_msg(LVL_DEBUG, "tcp_sock_listen()");
     252        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
    253253
    254254        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    284284        }
    285285
    286         log_msg(LVL_DEBUG, " - open connections");
     286        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
    287287
    288288        lsocket.addr.ipv4 = TCP_IPV4_ANY;
    … …  
    337337        tcp_sock_t fsocket;
    338338
    339         log_msg(LVL_DEBUG, "tcp_sock_connect()");
     339        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
    340340
    341341        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    … …  
    377377                        fibril_mutex_unlock(&socket->lock);
    378378                        async_answer_0(callid, rc);
    379                         log_msg(LVL_DEBUG, "tcp_sock_connect: Failed to "
     379                        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to "
    380380                            "determine local address.");
    381381                        return;
    … …  
    383383
    384384                socket->laddr.ipv4 = loc_addr.ipv4;
    385                 log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
     385                log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
    386386        }
    387387
    … …  
    431431        int rc;
    432432
    433         log_msg(LVL_DEBUG, "tcp_sock_accept()");
     433        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept()");
    434434
    435435        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    445445        fibril_mutex_lock(&socket->lock);
    446446
    447         log_msg(LVL_DEBUG, " - verify socket->conn");
     447        log_msg(LOG_DEFAULT, LVL_DEBUG, " - verify socket->conn");
    448448        if (socket->conn != NULL) {
    449449                fibril_mutex_unlock(&socket->lock);
    … …  
    498498
    499499        asocket->conn = conn;
    500         log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
     500        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept():create asocket\n");
    501501
    502502        rc = tcp_sock_finish_setup(asocket, &asock_id);
    … …  
    510510        fibril_add_ready(asocket->recv_fibril);
    511511
    512         log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
     512        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): find acore\n");
    513513
    514514        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    … …  
    521521       
    522522        /* Push one fragment notification to client's queue */
    523         log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
     523        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    524524        fibril_mutex_unlock(&socket->lock);
    525525}
    … …  
    539539        int rc;
    540540
    541         log_msg(LVL_DEBUG, "tcp_sock_send()");
     541        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_send()");
    542542        socket_id = SOCKET_GET_SOCKET_ID(call);
    543543        fragments = SOCKET_GET_DATA_FRAGMENTS(call);
    … …  
    611611static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    612612{
    613         log_msg(LVL_DEBUG, "tcp_sock_sendto()");
     613        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_sendto()");
    614614        async_answer_0(callid, ENOTSUP);
    615615}
    … …  
    629629        int rc;
    630630
    631         log_msg(LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
     631        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
    632632
    633633        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    651651        (void)flags;
    652652
    653         log_msg(LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     653        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
    654654        fibril_mutex_lock(&socket->recv_buffer_lock);
    655655        while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
    656                 log_msg(LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
     656                log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
    657657                fibril_condvar_wait(&socket->recv_buffer_cv,
    658658                    &socket->recv_buffer_lock);
    659659        }
    660660
    661         log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
     661        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    662662
    663663        data_len = socket->recv_buffer_used;
    … …  
    679679        }
    680680
    681         log_msg(LVL_DEBUG, "**** recv result -> %d", rc);
     681        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc);
    682682        if (rc != EOK) {
    683683                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    694694                addr.sin_port = host2uint16_t_be(rsock->port);
    695695
    696                 log_msg(LVL_DEBUG, "addr read receive");
     696                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
    697697                if (!async_data_read_receive(&rcallid, &addr_length)) {
    698698                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    705705                        addr_length = sizeof(addr);
    706706
    707                 log_msg(LVL_DEBUG, "addr read finalize");
     707                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
    708708                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    709709                if (rc != EOK) {
    … …  
    715715        }
    716716
    717         log_msg(LVL_DEBUG, "data read receive");
     717        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
    718718        if (!async_data_read_receive(&rcallid, &length)) {
    719719                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    726726                length = data_len;
    727727
    728         log_msg(LVL_DEBUG, "data read finalize");
     728        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
    729729        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    730730
    731731        socket->recv_buffer_used -= length;
    732         log_msg(LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
     732        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
    733733            socket->recv_buffer_used);
    734734        if (socket->recv_buffer_used > 0) {
    … …  
    758758        int rc;
    759759
    760         log_msg(LVL_DEBUG, "tcp_sock_close()");
     760        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
    761761        socket_id = SOCKET_GET_SOCKET_ID(call);
    762762
    … …  
    798798static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    799799{
    800         log_msg(LVL_DEBUG, "tcp_sock_getsockopt()");
     800        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_getsockopt()");
    801801        async_answer_0(callid, ENOTSUP);
    802802}
    … …  
    804804static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    805805{
    806         log_msg(LVL_DEBUG, "tcp_sock_setsockopt()");
     806        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_setsockopt()");
    807807        async_answer_0(callid, ENOTSUP);
    808808}
    … …  
    815815        tcp_sockdata_t *socket = lconn->socket;
    816816
    817         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()");
     817        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb()");
    818818        fibril_mutex_lock(&socket->lock);
    819819        assert(conn == lconn->conn);
    … …  
    828828        list_append(&lconn->ready_list, &socket->ready);
    829829
    830         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
     830        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
    831831
    832832        /* Push one accept notification to client's queue */
    … …  
    842842        tcp_error_t trc;
    843843
    844         log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()");
     844        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recv_fibril()");
    845845
    846846        fibril_mutex_lock(&sock->recv_buffer_lock);
    847847
    848848        while (true) {
    849                 log_msg(LVL_DEBUG, "call tcp_uc_receive()");
     849                log_msg(LOG_DEFAULT, LVL_DEBUG, "call tcp_uc_receive()");
    850850                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL)
    851851                        fibril_condvar_wait(&sock->recv_buffer_cv,
    … …  
    863863                }
    864864
    865                 log_msg(LVL_DEBUG, "got data - broadcast recv_buffer_cv");
     865                log_msg(LOG_DEFAULT, LVL_DEBUG, "got data - broadcast recv_buffer_cv");
    866866
    867867                sock->recv_buffer_used = data_len;
    … …  
    895895                        break;
    896896
    897                 log_msg(LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
     897                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
    898898                    (int)IPC_GET_IMETHOD(call));
    899899
    … …  
    940940
    941941        /* Clean up */
    942         log_msg(LVL_DEBUG, "tcp_sock_connection: Clean up");
     942        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: Clean up");
    943943        async_hangup(client.sess);
    944944        socket_cores_release(NULL, &client.sockets, &gsock, tcp_free_sock_data);

  • uspace/srv/net/tcp/tcp.c

    r920d0fc ra1a101d  
    6969        size_t pdu_raw_size;
    7070
    71         log_msg(LVL_DEBUG, "tcp_inet_ev_recv()");
     71        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_ev_recv()");
    7272
    7373        pdu_raw = dgram->data;
    … …  
    7676        /* Split into header and payload. */
    7777
    78         log_msg(LVL_DEBUG, "tcp_inet_ev_recv() - split header/payload");
     78        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_inet_ev_recv() - split header/payload");
    7979
    8080        tcp_pdu_t *pdu;
    … …  
    8484
    8585        if (pdu_raw_size < sizeof(tcp_header_t)) {
    86                 log_msg(LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu",
     86                log_msg(LOG_DEFAULT, LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu",
    8787                    pdu_raw_size, sizeof(tcp_header_t));
    8888                return EINVAL;
    … …  
    9696
    9797        if (pdu_raw_size < hdr_size) {
    98                 log_msg(LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu",
     98                log_msg(LOG_DEFAULT, LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu",
    9999                    pdu_raw_size, hdr_size);
    100100                return EINVAL;
    … …  
    102102
    103103        if (hdr_size < sizeof(tcp_header_t)) {
    104                 log_msg(LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu",
     104                log_msg(LOG_DEFAULT, LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu",
    105105                    hdr_size, sizeof(tcp_header_t));            return EINVAL;
    106106        }
    107107
    108         log_msg(LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu",
     108        log_msg(LOG_DEFAULT, LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu",
    109109            pdu_raw_size, hdr_size);
    110110        pdu = tcp_pdu_create(pdu_raw, hdr_size, pdu_raw + hdr_size,
    111111            pdu_raw_size - hdr_size);
    112112        if (pdu == NULL) {
    113                 log_msg(LVL_WARN, "Failed creating PDU. Dropped.");
     113                log_msg(LOG_DEFAULT, LVL_WARN, "Failed creating PDU. Dropped.");
    114114                return ENOMEM;
    115115        }
    … …  
    117117        pdu->src_addr.ipv4 = dgram->src.ipv4;
    118118        pdu->dest_addr.ipv4 = dgram->dest.ipv4;
    119         log_msg(LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
     119        log_msg(LOG_DEFAULT, LVL_DEBUG, "src: 0x%08x, dest: 0x%08x",
    120120            pdu->src_addr.ipv4, pdu->dest_addr.ipv4);
    121121
    … …  
    137137        pdu_raw = malloc(pdu_raw_size);
    138138        if (pdu_raw == NULL) {
    139                 log_msg(LVL_ERROR, "Failed to transmit PDU. Out of memory.");
     139                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU. Out of memory.");
    140140                return;
    141141        }
    … …  
    153153        rc = inet_send(&dgram, INET_TTL_MAX, 0);
    154154        if (rc != EOK)
    155                 log_msg(LVL_ERROR, "Failed to transmit PDU.");
     155                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to transmit PDU.");
    156156}
    157157
    … …  
    162162        tcp_sockpair_t rident;
    163163
    164         log_msg(LVL_DEBUG, "tcp_received_pdu()");
     164        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_received_pdu()");
    165165
    166166        if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) {
    167                 log_msg(LVL_WARN, "Not enough memory. PDU dropped.");
     167                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. PDU dropped.");
    168168                return;
    169169        }
    … …  
    177177        int rc;
    178178
    179         log_msg(LVL_DEBUG, "tcp_init()");
     179        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_init()");
    180180
    181181        tcp_rqueue_init();
    … …  
    189189        rc = inet_init(IP_PROTO_TCP, &tcp_inet_ev_ops);
    190190        if (rc != EOK) {
    191                 log_msg(LVL_ERROR, "Failed connecting to internet service.");
     191                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed connecting to internet service.");
    192192                return ENOENT;
    193193        }
    … …  
    195195        rc = tcp_sock_init();
    196196        if (rc != EOK) {
    197                 log_msg(LVL_ERROR, "Failed initializing socket service.");
     197                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
    198198                return ENOENT;
    199199        }

  • uspace/srv/net/tcp/tqueue.c

    r920d0fc ra1a101d  
    8888        tcp_segment_t *seg;
    8989
    90         log_msg(LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl);
     90        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl);
    9191
    9292        seg = tcp_segment_make_ctrl(ctrl);
    … …  
    9999        tcp_tqueue_entry_t *tqe;
    100100
    101         log_msg(LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn,
     101        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn,
    102102            seg);
    103103
    … …  
    109109                rt_seg = tcp_segment_dup(seg);
    110110                if (rt_seg == NULL) {
    111                         log_msg(LVL_ERROR, "Memory allocation failed.");
     111                        log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
    112112                        /* XXX Handle properly */
    113113                        return;
    … …  
    116116                tqe = calloc(1, sizeof(tcp_tqueue_entry_t));
    117117                if (tqe == NULL) {
    118                         log_msg(LVL_ERROR, "Memory allocation failed.");
     118                        log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
    119119                        /* XXX Handle properly */
    120120                        return;
    … …  
    165165        tcp_segment_t *seg;
    166166
    167         log_msg(LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name);
     167        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name);
    168168
    169169        /* Number of free sequence numbers in send window */
    … …  
    172172
    173173        xfer_seqlen = min(snd_buf_seqlen, avail_wnd);
    174         log_msg(LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %zu, "
     174        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %zu, "
    175175            "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd,
    176176            xfer_seqlen);
    … …  
    185185
    186186        if (send_fin) {
    187                 log_msg(LVL_DEBUG, "%s: Sending out FIN.", conn->name);
     187                log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Sending out FIN.", conn->name);
    188188                /* We are sending out FIN */
    189189                ctrl = CTL_FIN;
    … …  
    194194        seg = tcp_segment_make_data(ctrl, conn->snd_buf, data_size);
    195195        if (seg == NULL) {
    196                 log_msg(LVL_ERROR, "Memory allocation failure.");
     196                log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failure.");
    197197                return;
    198198        }
    … …  
    223223        link_t *cur, *next;
    224224
    225         log_msg(LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name,
     225        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name,
    226226            conn);
    227227
    … …  
    239239
    240240                        if ((tqe->seg->ctrl & CTL_FIN) != 0) {
    241                                 log_msg(LVL_DEBUG, "Fin has been acked");
    242                                 log_msg(LVL_DEBUG, "SND.UNA=%" PRIu32
     241                                log_msg(LOG_DEFAULT, LVL_DEBUG, "Fin has been acked");
     242                                log_msg(LOG_DEFAULT, LVL_DEBUG, "SND.UNA=%" PRIu32
    243243                                    " SEG.SEQ=%" PRIu32 " SEG.LEN=%" PRIu32,
    244244                                    conn->snd_una, tqe->seg->seq, tqe->seg->len);
    … …  
    267267void tcp_conn_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg)
    268268{
    269         log_msg(LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)",
     269        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)",
    270270            conn->name, conn, seg);
    271271
    … …  
    282282void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
    283283{
    284         log_msg(LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)",
     284        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)",
    285285            sp->foreign.addr.ipv4, sp->foreign.port,
    286286            sp->local.addr.ipv4, sp->local.port, seg);
    287287
    288         log_msg(LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
     288        log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
    289289            seg->seq, seg->wnd);
    290290
    … …  
    300300
    301301        if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
    302                 log_msg(LVL_WARN, "Not enough memory. Segment dropped.");
     302                log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
    303303                return;
    304304        }
    … …  
    315315        link_t *link;
    316316
    317         log_msg(LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
     317        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
    318318
    319319        fibril_mutex_lock(&conn->lock);
    320320
    321321        if (conn->cstate == st_closed) {
    322                 log_msg(LVL_DEBUG, "Connection already closed.");
     322                log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection already closed.");
    323323                fibril_mutex_unlock(&conn->lock);
    324324                tcp_conn_delref(conn);
    … …  
    328328        link = list_first(&conn->retransmit.list);
    329329        if (link == NULL) {
    330                 log_msg(LVL_DEBUG, "Nothing to retransmit");
     330                log_msg(LOG_DEFAULT, LVL_DEBUG, "Nothing to retransmit");
    331331                fibril_mutex_unlock(&conn->lock);
    332332                tcp_conn_delref(conn);
    … …  
    338338        rt_seg = tcp_segment_dup(tqe->seg);
    339339        if (rt_seg == NULL) {
    340                 log_msg(LVL_ERROR, "Memory allocation failed.");
     340                log_msg(LOG_DEFAULT, LVL_ERROR, "Memory allocation failed.");
    341341                fibril_mutex_unlock(&conn->lock);
    342342                tcp_conn_delref(conn);
    … …  
    345345        }
    346346
    347         log_msg(LVL_DEBUG, "### %s: retransmitting segment", conn->name);
     347        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmitting segment", conn->name);
    348348        tcp_conn_transmit_segment(tqe->conn, rt_seg);
    349349
    … …  
    358358static void tcp_tqueue_timer_set(tcp_conn_t *conn)
    359359{
    360         log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
     360        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
    361361
    362362        /* Clear first to make sure we update refcnt correctly */
    … …  
    371371static void tcp_tqueue_timer_clear(tcp_conn_t *conn)
    372372{
    373         log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
     373        log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
    374374
    375375        if (fibril_timer_clear(conn->retransmit.timer) == fts_active)

  • uspace/srv/net/tcp/ucall.c

    r920d0fc ra1a101d  
    7070        tcp_conn_t *nconn;
    7171
    72         log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
     72        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
    7373            lsock, fsock, acpass == ap_active ? "active" : "passive",
    7474            oflags == tcp_open_nonblock ? "nonblock" : "none", conn);
    … …  
    8888
    8989        /* Wait for connection to be established or reset */
    90         log_msg(LVL_DEBUG, "tcp_uc_open: Wait for connection.");
     90        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Wait for connection.");
    9191        fibril_mutex_lock(&nconn->lock);
    9292        while (nconn->cstate == st_listen ||
    … …  
    9797
    9898        if (nconn->cstate != st_established) {
    99                 log_msg(LVL_DEBUG, "tcp_uc_open: Connection was reset.");
     99                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was reset.");
    100100                assert(nconn->cstate == st_closed);
    101101                fibril_mutex_unlock(&nconn->lock);
    … …  
    104104
    105105        fibril_mutex_unlock(&nconn->lock);
    106         log_msg(LVL_DEBUG, "tcp_uc_open: Connection was established.");
     106        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open: Connection was established.");
    107107
    108108        *conn = nconn;
    109         log_msg(LVL_DEBUG, "tcp_uc_open -> %p", nconn);
     109        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open -> %p", nconn);
    110110        return TCP_EOK;
    111111}
    … …  
    118118        size_t xfer_size;
    119119
    120         log_msg(LVL_DEBUG, "%s: tcp_uc_send()", conn->name);
     120        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_send()", conn->name);
    121121
    122122        fibril_mutex_lock(&conn->lock);
    … …  
    141141                buf_free = conn->snd_buf_size - conn->snd_buf_used;
    142142                while (buf_free == 0 && !conn->reset) {
    143                         log_msg(LVL_DEBUG, "%s: buf_free == 0, waiting.",
     143                        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: buf_free == 0, waiting.",
    144144                            conn->name);
    145145                        fibril_condvar_wait(&conn->snd_buf_cv, &conn->lock);
    … …  
    175175        size_t xfer_size;
    176176
    177         log_msg(LVL_DEBUG, "%s: tcp_uc_receive()", conn->name);
     177        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive()", conn->name);
    178178
    179179        fibril_mutex_lock(&conn->lock);
    … …  
    186186        /* Wait for data to become available */
    187187        while (conn->rcv_buf_used == 0 && !conn->rcv_buf_fin && !conn->reset) {
    188                 log_msg(LVL_DEBUG, "tcp_uc_receive() - wait for data");
     188                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_receive() - wait for data");
    189189                fibril_condvar_wait(&conn->rcv_buf_cv, &conn->lock);
    190190        }
    … …  
    223223        tcp_tqueue_ctrl_seg(conn, CTL_ACK);
    224224
    225         log_msg(LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes",
     225        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes",
    226226            conn->name, xfer_size);
    227227
    … …  
    234234tcp_error_t tcp_uc_close(tcp_conn_t *conn)
    235235{
    236         log_msg(LVL_DEBUG, "%s: tcp_uc_close()", conn->name);
     236        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_close()", conn->name);
    237237
    238238        fibril_mutex_lock(&conn->lock);
    … …  
    258258void tcp_uc_abort(tcp_conn_t *conn)
    259259{
    260         log_msg(LVL_DEBUG, "tcp_uc_abort()");
     260        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_abort()");
    261261}
    262262
    … …  
    264264void tcp_uc_status(tcp_conn_t *conn, tcp_conn_status_t *cstatus)
    265265{
    266         log_msg(LVL_DEBUG, "tcp_uc_status()");
     266        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_status()");
    267267        cstatus->cstate = conn->cstate;
    268268}
    … …  
    276276void tcp_uc_delete(tcp_conn_t *conn)
    277277{
    278         log_msg(LVL_DEBUG, "tcp_uc_delete()");
     278        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_delete()");
    279279        tcp_conn_delete(conn);
    280280}
    … …  
    282282void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg)
    283283{
    284         log_msg(LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
     284        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
    285285            conn, cb, arg);
    286286
    … …  
    298298        tcp_conn_t *conn;
    299299
    300         log_msg(LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))",
     300        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))",
    301301            sp->foreign.addr.ipv4, sp->foreign.port,
    302302            sp->local.addr.ipv4, sp->local.port);
    … …  
    304304        conn = tcp_conn_find_ref(sp);
    305305        if (conn == NULL) {
    306                 log_msg(LVL_WARN, "No connection found.");
     306                log_msg(LOG_DEFAULT, LVL_WARN, "No connection found.");
    307307                tcp_unexpected_segment(sp, seg);
    308308                return;
    … …  
    312312
    313313        if (conn->cstate == st_closed) {
    314                 log_msg(LVL_WARN, "Connection is closed.");
     314                log_msg(LOG_DEFAULT, LVL_WARN, "Connection is closed.");
    315315                tcp_unexpected_segment(sp, seg);
    316316                fibril_mutex_unlock(&conn->lock);
    … …  
    339339void tcp_to_user(void)
    340340{
    341         log_msg(LVL_DEBUG, "tcp_to_user()");
     341        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_to_user()");
    342342}
    343343
Note: See TracChangeset for help on using the changeset viewer.