Changes in / [ecf823a:3819ce5] in mainline


Ignore:
Files:
1 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    recf823a r3819ce5  
    128128        nic/lo \
    129129        nic/ne2k \
    130         nic/e1k \
    131         nic/rtl8139
     130        nic/e1k
    132131
    133132RD_DRV_CFG =

  • contrib/conf/net-qe.sh

    recf823a r3819ce5  
    1010                qemu $@ -device e1000,vlan=0 -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
    1111                ;;
    12         rtl8139)
    13                 shift
    14                 qemu $@ -device rtl8139,vlan=0 -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
    15                 ;;
    1612        *)
    17                 echo "Usage: $0 {ne2k|e1k|rtl8139}"
     13                echo "Usage: $0 {ne2k|e1k}"
    1814esac

  • uspace/Makefile

    recf823a r3819ce5  
    122122        drv/nic/lo \
    123123        drv/nic/ne2k \
    124         drv/nic/e1k \
    125         drv/nic/rtl8139
     124        drv/nic/e1k
    126125
    127126ifeq ($(CONFIG_PCC),y)

  • uspace/app/websrv/websrv.c

    recf823a r3819ce5  
    4949
    5050#define PORT_NUMBER 8080
    51 #define BACKLOG_SIZE 3
    5251
    5352#define WEB_ROOT "/data/web"
    … …  
    276275        }
    277276
    278         rc = listen(listen_sd, BACKLOG_SIZE);
     277        rc = listen(listen_sd, 1);
    279278        if (rc != EOK) {
    280279                printf("Error calling listen() (%d).\n", rc);

  • uspace/dist/data/web/index.htm

    recf823a r3819ce5  
    77    <body>
    88        <h1>Hello from HelenOS!</h1>
    9         <img src="helenos.png" alt="" style="float: left; margin: 6px;">
    109        <p>
    1110            This web page is brought to you by courtesy of HelenOS web server

  • uspace/drv/bus/usb/ohci/root_hub.c

    recf823a r3819ce5  
    226226                fibril_mutex_lock(&instance->guard);
    227227                assert(instance->unfinished_interrupt_transfer == NULL);
    228                 uint16_t mask = create_interrupt_mask(instance);
     228                const uint16_t mask = create_interrupt_mask(instance);
    229229                if (mask == 0) {
    230230                        usb_log_debug("No changes...\n");
    … …  
    257257        if (instance->unfinished_interrupt_transfer) {
    258258                usb_log_debug("Finalizing interrupt transfer\n");
    259                 uint16_t mask = create_interrupt_mask(instance);
     259                const uint16_t mask = create_interrupt_mask(instance);
    260260                interrupt_request(instance->unfinished_interrupt_transfer,
    261261                    mask, instance->interrupt_mask_size);
    … …  
    278278
    279279        /* 7 bytes + 2 port bit fields (port count + global bit) */
    280         size_t size = 7 + (instance->interrupt_mask_size * 2);
     280        const size_t size = 7 + (instance->interrupt_mask_size * 2);
    281281        assert(size <= HUB_DESCRIPTOR_MAX_SIZE);
    282282        instance->hub_descriptor_size = size;
    283283
    284         uint32_t hub_desc = instance->registers->rh_desc_a;
    285         uint32_t port_desc = instance->registers->rh_desc_b;
     284        const uint32_t hub_desc = instance->registers->rh_desc_a;
     285        const uint32_t port_desc = instance->registers->rh_desc_b;
    286286
    287287        /* bDescLength */
    … …  
    394394
    395395
    396         usb_device_request_setup_packet_t *request_packet =
     396        const usb_device_request_setup_packet_t *request_packet =
    397397            (usb_device_request_setup_packet_t*)request->setup_buffer;
    398398
    … …  
    406406                        TRANSFER_END(request, EOVERFLOW);
    407407                } else {
    408                         uint32_t data = instance->registers->rh_status &
     408                        const uint32_t data = instance->registers->rh_status &
    409409                            (RHS_LPS_FLAG | RHS_LPSC_FLAG
    410410                                | RHS_OCI_FLAG | RHS_OCIC_FLAG);
    … …  
    420420                        TRANSFER_END(request, EOVERFLOW);
    421421                } else {
    422                         unsigned port = request_packet->index;
     422                        const unsigned port = request_packet->index;
    423423                        if (port < 1 || port > instance->port_count)
    424424                                TRANSFER_END(request, EINVAL);
    425425
    426                         uint32_t data =
     426                        const uint32_t data =
    427427                            instance->registers->rh_port_status[port - 1];
    428428                        TRANSFER_END_DATA(request, &data, sizeof(data));
    … …  
    434434                        TRANSFER_END(request, EOVERFLOW);
    435435                } else {
    436                         uint16_t data =
     436                        static const uint16_t data =
    437437                            uint16_host2usb(USB_DEVICE_STATUS_SELF_POWERED);
    438438                        TRANSFER_END_DATA(request, &data, sizeof(data));
    … …  
    455455                } else {
    456456                        /* Endpoints are OK. (We don't halt) */
    457                         uint16_t data = 0;
     457                        static const uint16_t data = 0;
    458458                        TRANSFER_END_DATA(request, &data, sizeof(data));
    459459                }
    … …  
    480480        assert(request);
    481481
    482         usb_device_request_setup_packet_t *setup_request =
     482        const usb_device_request_setup_packet_t *setup_request =
    483483            (usb_device_request_setup_packet_t *) request->setup_buffer;
    484         uint16_t setup_request_value = setup_request->value_high;
     484        const uint16_t setup_request_value = setup_request->value_high;
    485485        switch (setup_request_value)
    486486        {
    … …  
    648648        assert(request);
    649649
    650         usb_device_request_setup_packet_t *setup_request =
     650        const usb_device_request_setup_packet_t *setup_request =
    651651            (usb_device_request_setup_packet_t *) request->setup_buffer;
    652652        switch (setup_request->request_type)
    … …  
    654654        case USB_HUB_REQ_TYPE_SET_PORT_FEATURE:
    655655                usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    656                 int ret = set_feature_port(instance,
     656                const int ret = set_feature_port(instance,
    657657                    setup_request->value, setup_request->index);
    658658                TRANSFER_END(request, ret);
    … …  
    686686        assert(request);
    687687
    688         usb_device_request_setup_packet_t *setup_request =
     688        const usb_device_request_setup_packet_t *setup_request =
    689689            (usb_device_request_setup_packet_t *) request->setup_buffer;
    690690
    … …  
    693693        case USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE:
    694694                usb_log_debug("USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE\n");
    695                 int ret = clear_feature_port(instance,
     695                const int ret = clear_feature_port(instance,
    696696                    setup_request->value, setup_request->index);
    697697                TRANSFER_END(request, ret);
    … …  
    753753        usb_log_debug2("CTRL packet: %s.\n",
    754754            usb_debug_str_buffer((uint8_t *) request->setup_buffer, 8, 8));
    755         usb_device_request_setup_packet_t *setup_request =
     755        const usb_device_request_setup_packet_t *setup_request =
    756756            (usb_device_request_setup_packet_t *) request->setup_buffer;
    757757        switch (setup_request->request)
    … …  
    771771                if (request->buffer_size == 0)
    772772                        TRANSFER_END(request, EOVERFLOW);
    773                 uint8_t config = 1;
     773                static const uint8_t config = 1;
    774774                TRANSFER_END_DATA(request, &config, sizeof(config));
    775775

  • uspace/drv/infrastructure/rootmac/rootmac.c

    recf823a r3819ce5  
    161161
    162162static hw_res_ops_t fun_hw_res_ops = {
    163         .get_resource_list = &rootmac_get_resources,
    164         .enable_interrupt = &rootmac_enable_interrupt
     163        &rootmac_get_resources,
     164        &rootmac_enable_interrupt
    165165};
    166166

  • uspace/drv/nic/rtl8139/defs.c

    recf823a r3819ce5  
    2727 */
    2828
    29 #include "defs.h"
     29#include "rtl8139_defs.h"
    3030
    3131const char* model_names[RTL8139_VER_COUNT] = {

  • uspace/drv/nic/rtl8139/driver.c

    recf823a r3819ce5  
    3333#include <libarch/ddi.h>
    3434#include <libarch/barrier.h>
    35 
    36 #include <as.h>
    37 #include <ddf/log.h>
     35#include <nlog.h>
     36
     37#include <dma.h>
    3838#include <ddf/interrupt.h>
    39 #include <io/log.h>
     39#include <devman.h>
    4040#include <nic.h>
    4141#include <packet_client.h>
    … …  
    5050#include <str.h>
    5151
    52 #include "defs.h"
    53 #include "driver.h"
    54 #include "general.h"
     52#include "rtl8139_defs.h"
     53#include "rtl8139_driver.h"
     54#include "rtl8139_general.h"
    5555
    5656/** Global mutex for work with shared irq structure */
    … …  
    164164            (RXBUF_SIZE_FLAGS << RCR_RBLEN_SHIFT);
    165165       
    166         ddf_msg(LVL_DEBUG, "Rewriting rcr: %x -> %x", pio_read_32(rtl8139->io_port + RCR),
     166        nlog_debug("Rewriting rcr: %x -> %x", pio_read_32(rtl8139->io_port + RCR),
    167167            rcr);
    168168
    … …  
    373373static ddf_dev_ops_t rtl8139_dev_ops;
    374374
    375 static int rtl8139_dev_add(ddf_dev_t *dev);
     375static int rtl8139_add_device(ddf_dev_t *dev);
    376376
    377377/** Basic driver operations for RTL8139 driver */
    378378static driver_ops_t rtl8139_driver_ops = {
    379         .dev_add = &rtl8139_dev_add,
     379        .add_device = &rtl8139_add_device,
    380380};
    381381
    … …  
    409409        rtl8139_t *rtl8139 = nic_get_specific(nic_data);
    410410        assert(rtl8139);
    411         ddf_msg(LVL_DEBUG, "Sending packet");
     411        nlog_debug("Sending packet");
    412412
    413413        /* Get the packet data and check if it can be send */
    … …  
    418418
    419419        if ((packet_length > RTL8139_PACKET_MAX_LENGTH) || !packet_data) {
    420                 ddf_msg(LVL_ERROR, "Write packet length error: data %p, length %z",
     420                nlog_error("Write packet length error: data %p, length %z",
    421421                    packet_data, packet_length);
    422422                nic_report_send_error(rtl8139->nic_data, NIC_SEC_OTHER, 1);
    … …  
    527527        nic_frame_t *frame = nic_alloc_frame(nic_data, packet_size);
    528528        if (! frame) {
    529                 ddf_msg(LVL_ERROR, "Can not allocate frame for received packet.");
     529                nlog_error("Can not allocate frame for received packet.");
    530530                return NULL;
    531531        }
    … …  
    533533        void *packet_data = packet_suffix(frame->packet, packet_size);
    534534        if (!packet_data) {
    535                 ddf_msg(LVL_ERROR, "Can not get the packet suffix.");
     535                nlog_error("Can not get the packet suffix.");
    536536                nic_release_frame(nic_data, frame);
    537537                return NULL;
    … …  
    564564        pio_write_32(rtl8139->io_port + CAPR, 0);
    565565        pio_write_32(rtl8139->io_port + RBSTART,
    566             PTR2U32(rtl8139->rx_buff_phys));
     566            PTR2U32(rtl8139->rx_buff.physical));
    567567
    568568        write_barrier();
    … …  
    588588        nic_frame_list_t *frames = nic_alloc_frame_list();
    589589        if (!frames)
    590                 ddf_msg(LVL_ERROR, "Can not allocate frame list for received packets.");
    591 
    592         void *rx_buffer = rtl8139->rx_buff_virt;
     590                nlog_error("Can not allocate frame list for received packets.");
     591
     592        void *rx_buffer = rtl8139->rx_buff.virtual;
    593593
    594594        /* where to start reading */
    … …  
    620620                if (size == RTL8139_EARLY_SIZE) {
    621621                        /* The packet copying is still in progress, break receiving */
    622                         ddf_msg(LVL_DEBUG, "Early threshold reached, not completely coppied");
     622                        nlog_debug("Early threshold reached, not completely coppied");
    623623                        break;
    624624                }
    … …  
    626626                /* Check if the header is valid, otherwise we are lost in the buffer */
    627627                if (size == 0 || size > RTL8139_PACKET_MAX_LENGTH) {
    628                         ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (size: %4"PRIu16", "
     628                        nlog_error("Receiver error -> receiver reset (size: %4"PRIu16", "
    629629                            "header 0x%4"PRIx16". Offset: %zu)", size, packet_header,
    630630                            rx_offset);
    … …  
    632632                }
    633633                if (size < RTL8139_RUNT_MAX_SIZE && !(rcs & RSR_RUNT)) {
    634                         ddf_msg(LVL_ERROR, "Receiver error -> receiver reset (%"PRIx16")", size);
     634                        nlog_error("Receiver error -> receiver reset (%"PRIx16")", size);
    635635                        goto rx_err;
    636636                }
    … …  
    801801        pio_write_32(rtl8139->io_port + TIMERINT, timer_val);
    802802        pio_write_32(rtl8139->io_port + TCTR, 0x0);
    803         ddf_msg(LVL_DEBUG, "rtl8139 timer: %"PRIu32"\treceive: %d", timer_val, receive);
     803        nlog_debug("rtl8139 timer: %"PRIu32"\treceive: %d", timer_val, receive);
    804804        return receive;
    805805}
    … …  
    925925        /* Write transmittion buffer addresses */
    926926        for(i = 0; i < TX_BUFF_COUNT; ++i) {
    927                 uint32_t addr = PTR2U32(rtl8139->tx_buff_phys + i*TX_BUFF_SIZE);
     927                uint32_t addr = PTR2U32(rtl8139->tx_buff_mem.physical + i*TX_BUFF_SIZE);
    928928                pio_write_32(io_base + TSAD0 + 4*i, addr);
    929929        }
    … …  
    932932        nic_set_tx_busy(rtl8139->nic_data, 0);
    933933
    934         pio_write_32(io_base + RBSTART, PTR2U32(rtl8139->rx_buff_phys));
     934        pio_write_32(io_base + RBSTART, PTR2U32(rtl8139->rx_buff.physical));
    935935
    936936        /* Enable transmitter and receiver */
    … …  
    949949{
    950950        assert(nic_data);
    951         ddf_msg(LVL_NOTE, "Activating device");
     951        nlog_info("Activating device");
    952952
    953953        rtl8139_t *rtl8139 = nic_get_specific(nic_data);
    … …  
    962962        nic_enable_interrupt(nic_data, rtl8139->irq);
    963963
    964         ddf_msg(LVL_DEBUG, "Device activated, interrupt %d registered", rtl8139->irq);
     964        nlog_debug("Device activated, interrupt %d registered", rtl8139->irq);
    965965        return EOK;
    966966}
    … …  
    10791079
    10801080        if (hw_resources->irqs.count != 1) {
    1081                 ddf_msg(LVL_ERROR, "%s device: unexpected irq count", dev->name);
     1081                nlog_error("%s device: unexpected irq count", dev->name);
    10821082                return EINVAL;
    10831083        };
    10841084        if (hw_resources->io_ranges.count != 1) {
    1085                 ddf_msg(LVL_ERROR, "%s device: unexpected io ranges count", dev->name);
     1085                nlog_error("%s device: unexpected io ranges count", dev->name);
    10861086                return EINVAL;
    10871087        }
    10881088
    10891089        rtl8139->irq = hw_resources->irqs.irqs[0];
    1090         ddf_msg(LVL_DEBUG, "%s device: irq 0x%x assigned", dev->name, rtl8139->irq);
     1090        nlog_debug("%s device: irq 0x%x assigned", dev->name, rtl8139->irq);
    10911091
    10921092        rtl8139->io_addr = IOADDR_TO_PTR(hw_resources->io_ranges.ranges[0].address);
    10931093        if (hw_resources->io_ranges.ranges[0].size < RTL8139_IO_SIZE) {
    1094                 ddf_msg(LVL_ERROR, "i/o range assigned to the device "
     1094                nlog_error("i/o range assigned to the device "
    10951095                    "%s is too small.", dev->name);
    10961096                return EINVAL;
    10971097        }
    1098         ddf_msg(LVL_DEBUG, "%s device: i/o addr %p assigned.", dev->name, rtl8139->io_addr);
     1098        nlog_debug("%s device: i/o addr %p assigned.", dev->name, rtl8139->io_addr);
    10991099
    11001100        return EOK;
    … …  
    11421142static int rtl8139_buffers_create(rtl8139_t *rtl8139)
    11431143{
     1144        assert(rtl8139);
    11441145        size_t i = 0;
    11451146        int rc;
    11461147
    1147         ddf_msg(LVL_DEBUG, "Creating buffers");
    1148 
    1149         rc = dmamem_map_anonymous(TX_PAGES * PAGE_SIZE, AS_AREA_WRITE, 0,
    1150             &rtl8139->tx_buff_phys, &rtl8139->tx_buff_virt);
     1148        nlog_debug("Creating buffers");
     1149
     1150        rtl8139->tx_buff_mem.size = TX_PAGES;
     1151        rtl8139->tx_buff_mem.mapping_flags = AS_AREA_WRITE;
     1152        rc = dma_allocate_anonymous(&rtl8139->tx_buff_mem, DMA_32_BITS);
    11511153        if (rc != EOK) {
    1152                 ddf_msg(LVL_ERROR, "Can not allocate transmitter buffers.");
     1154                nlog_error("Can not allocate transmitter buffers.");
    11531155                goto err_tx_alloc;
    11541156        }
    11551157
    1156         for (i = 0; i < TX_BUFF_COUNT; ++i)
    1157                 rtl8139->tx_buff[i] = rtl8139->tx_buff_virt + i * TX_BUFF_SIZE;
    1158 
    1159         ddf_msg(LVL_DEBUG, "The transmittion buffers allocated");
     1158        for(i = 0; i < TX_BUFF_COUNT; ++i)
     1159                rtl8139->tx_buff[i] = rtl8139->tx_buff_mem.virtual + i * TX_BUFF_SIZE;
     1160
     1161        nlog_debug("The transmittion buffers allocated");
    11601162
    11611163        /* Use the first buffer for next transmittion */
    … …  
    11641166
    11651167        /* Allocate buffer for receiver */
    1166         ddf_msg(LVL_DEBUG, "Allocating receiver buffer of the size %zu bytes",
    1167             RxBUF_TOT_LENGTH);
    1168 
    1169         rc = dmamem_map_anonymous(RxBUF_TOT_LENGTH, AS_AREA_READ, 0,
    1170             &rtl8139->rx_buff_phys, &rtl8139->rx_buff_virt);
    1171         if (rc != EOK) {
    1172                 ddf_msg(LVL_ERROR, "Can not allocate receive buffer.");
     1168        size_t rx_pages = ALIGN_UP(RxBUF_TOT_LENGTH, PAGE_SIZE) / PAGE_SIZE;
     1169        nlog_debug("Allocating receiver buffer of the size %zd pages", rx_pages);
     1170
     1171        rtl8139->rx_buff.size = rx_pages;
     1172        rtl8139->rx_buff.mapping_flags = AS_AREA_READ;
     1173        rc = dma_allocate_anonymous(&rtl8139->rx_buff, DMA_32_BITS);
     1174        if( rc != EOK ) {
     1175                nlog_error("Can not allocate receiver buffer.");
    11731176                goto err_rx_alloc;
    11741177        }
    1175         ddf_msg(LVL_DEBUG, "The buffers created");
     1178        nlog_debug("The buffers created");
    11761179
    11771180        return EOK;
    11781181
    11791182err_rx_alloc:
    1180         dmamem_unmap_anonymous(&rtl8139->tx_buff_virt);
     1183        dma_free(&rtl8139->tx_buff_mem);
    11811184err_tx_alloc:
    11821185        return rc;
    … …  
    11911194static int rtl8139_device_initialize(ddf_dev_t *dev)
    11921195{
    1193         ddf_msg(LVL_DEBUG, "rtl8139_dev_initialize %s", dev->name);
     1196        nlog_debug("rtl8139_dev_initialize %s", dev->name);
    11941197
    11951198        int ret = EOK;
    11961199
    1197         ddf_msg(LVL_DEBUG, "rtl8139: creating device data");
     1200        nlog_debug("rtl8139: creating device data");
    11981201
    11991202        /* Allocate driver data for the device. */
    12001203        rtl8139_t *rtl8139 = rtl8139_create_dev_data(dev);
    12011204        if (rtl8139 == NULL) {
    1202                 ddf_msg(LVL_ERROR, "Not enough memory for initializing %s.", dev->name);
     1205                nlog_error("Not enough memory for initializing %s.", dev->name);
    12031206                return ENOMEM;
    12041207        }
    12051208
    1206         ddf_msg(LVL_DEBUG, "rtl8139: dev_data created");
     1209        nlog_debug("rtl8139: dev_data created");
    12071210
    12081211        /* Obtain and fill hardware resources info and connect to parent */
    12091212        ret = rtl8139_get_resource_info(dev);
    12101213        if (ret != EOK) {
    1211                 ddf_msg(LVL_ERROR, "Can not obatin hw resources information");
     1214                nlog_error("Can not obatin hw resources information");
    12121215                goto failed;
    12131216        }
    12141217
    1215         ddf_msg(LVL_DEBUG, "rtl8139: resource_info obtained");
     1218        nlog_debug("rtl8139: resource_info obtained");
    12161219
    12171220        /* Allocate DMA buffers */
    … …  
    12281231        rtl8139->rcr_data.rcr_base = (0x8 << RCR_ERTH_SHIFT);
    12291232
    1230         ddf_msg(LVL_DEBUG, "The device is initialized");
     1233        nlog_debug("The device is initialized");
    12311234        return ret;
    12321235
    12331236failed:
    1234         ddf_msg(LVL_ERROR, "The device initialization failed");
     1237        nlog_error("The device initialization failed");
    12351238        rtl8139_dev_cleanup(dev);
    12361239        return ret;
    … …  
    12451248static int rtl8139_pio_enable(ddf_dev_t *dev)
    12461249{
    1247         ddf_msg(LVL_DEBUG, NAME ": rtl8139_pio_enable %s", dev->name);
     1250        nlog_debug(NAME ": rtl8139_pio_enable %s", dev->name);
    12481251
    12491252        rtl8139_t *rtl8139 = nic_get_specific(nic_get_from_ddf_dev(dev));
    … …  
    12511254        /* Gain control over port's registers. */
    12521255        if (pio_enable(rtl8139->io_addr, RTL8139_IO_SIZE, &rtl8139->io_port)) {
    1253                 ddf_msg(LVL_ERROR, "Cannot gain the port %lx for device %s.", rtl8139->io_addr,
     1256                nlog_error("Cannot gain the port %lx for device %s.", rtl8139->io_addr,
    12541257                    dev->name);
    12551258                return EADDRNOTAVAIL;
    … …  
    12791282                if (rtl8139_versions[i].hwverid == hwverid) {
    12801283                        rtl8139->hw_version = rtl8139_versions[i].ver_id;
    1281                         ddf_msg(LVL_NOTE, "HW version found: index %zu, ver_id %d (%s)", i,
     1284                        nlog_info("HW version found: index %zu, ver_id %d (%s)", i,
    12821285                            rtl8139_versions[i].ver_id, model_names[rtl8139->hw_version]);
    12831286                }
    … …  
    12931296 * @return EOK if added successfully, negative error code otherwise
    12941297 */
    1295 int rtl8139_dev_add(ddf_dev_t *dev)
     1298int rtl8139_add_device(ddf_dev_t *dev)
    12961299{
    12971300        assert(dev);
    1298         ddf_msg(LVL_NOTE, "RTL8139_dev_add %s (handle = %d)", dev->name, dev->handle);
     1301        nlog_info("RTL8139_add_device %s (handle = %d)", dev->name, dev->handle);
    12991302
    13001303        /* Init device structure for rtl8139 */
    … …  
    13271330        rc = nic_connect_to_services(nic_data);
    13281331        if (rc != EOK) {
    1329                 ddf_msg(LVL_ERROR, "Failed to connect to services", rc);
     1332                nlog_error("Failed to connect to services", rc);
    13301333                goto err_irq;
    13311334        }
    … …  
    13331336        rc = nic_register_as_ddf_fun(nic_data, &rtl8139_dev_ops);
    13341337        if (rc != EOK) {
    1335                 ddf_msg(LVL_ERROR, "Failed to register as DDF function - error %d", rc);
     1338                nlog_error("Failed to register as DDF function - error %d", rc);
    13361339                goto err_irq;
    13371340        }
    13381341
    1339         ddf_msg(LVL_NOTE, "The %s device has been successfully initialized.",
     1342        nlog_info("The %s device has been successfully initialized.",
    13401343            dev->name);
    13411344
    … …  
    15781581
    15791582        if (allow_send && time > 0) {
    1580                 ddf_msg(LVL_WARN, "Time setting is not supported in set_pause method.");
     1583                nlog_warning("Time setting is not supported in set_pause method.");
    15811584        }
    15821585        return EOK;
    … …  
    21182121                pio_write_32(rtl8139->io_port + TCTR, 0);
    21192122
    2120                 ddf_msg(LVL_DEBUG, "Periodic mode. Interrupt mask %"PRIx16", poll.full_skips %"
     2123                nlog_debug("Periodic mode. Interrupt mask %"PRIx16", poll.full_skips %"
    21212124                    PRIu32", last timer %"PRIu32".", rtl8139->int_mask,
    21222125                    rtl8139->poll_timer.full_skips, rtl8139->poll_timer.last_val);
    … …  
    21652168                &rtl8139_driver_ops, &rtl8139_dev_ops, &rtl8139_nic_iface);
    21662169
    2167         ddf_log_init(NAME, LVL_ERROR);
    2168         ddf_msg(LVL_NOTE, "HelenOS RTL8139 driver started");
     2170        nlog_set_min_severity(DEBUG);
     2171        nlog_info("HelenOS RTL8139 driver started");
    21692172        return ddf_driver_main(&rtl8139_driver);
    21702173}

  • uspace/drv/nic/rtl8139/driver.h

    recf823a r3819ce5  
    3030#define RTL8139_DRIVER_H_
    3131
    32 #include "defs.h"
    33 #include "general.h"
     32#include "rtl8139_defs.h"
     33#include "rtl8139_general.h"
    3434#include <sys/types.h>
    3535#include <stdint.h>
     36#include <dma.h>
    3637
    3738/** The driver name */
    … …  
    9697         *  Each buffer takes 2kB
    9798         */
    98         void *tx_buff_phys;
    99         void *tx_buff_virt;
    100 
     99        dma_mem_t tx_buff_mem;
    101100        /** Virtual adresses of the Tx buffers */
    102101        void *tx_buff[TX_BUFF_COUNT];
    … …  
    113112
    114113        /** Buffer for receiving packets */
    115         void *rx_buff_phys;
    116         void *rx_buff_virt;
     114        dma_mem_t rx_buff;
    117115
    118116        /** Receiver control register data */

  • uspace/drv/nic/rtl8139/general.c

    recf823a r3819ce5  
    3232 */
    3333
    34 #include "general.h"
     34#include "rtl8139_general.h"
    3535
    3636#include <mem.h>

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

    recf823a r3819ce5  
    121121        fibril_condvar_initialize(&conn->cstate_cv);
    122122
    123         conn->cstate_cb = NULL;
    124 
    125123        conn->cstate = st_listen;
    126124        conn->reset = false;
    … …  
    245243        tcp_cstate_t old_state;
    246244
    247         log_msg(LVL_DEBUG, "tcp_conn_state_set(%p)", conn);
    248 
    249245        old_state = conn->cstate;
    250246        conn->cstate = nstate;
    251247        fibril_condvar_broadcast(&conn->cstate_cv);
    252 
    253         /* Run user callback function */
    254         if (conn->cstate_cb != NULL) {
    255                 log_msg(LVL_DEBUG, "tcp_conn_state_set() - run user CB");
    256                 conn->cstate_cb(conn, conn->cstate_cb_arg);
    257         } else {
    258                 log_msg(LVL_DEBUG, "tcp_conn_state_set() - no user CB");
    259         }
    260248
    261249        assert(old_state != st_closed);

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

    recf823a r3819ce5  
    5252#define FRAGMENT_SIZE 1024
    5353
    54 #define MAX_BACKLOG 128
    55 
    5654/** Free ports pool start. */
    5755#define TCP_FREE_PORTS_START            1025
    … …  
    6260static int last_used_port = TCP_FREE_PORTS_START - 1;
    6361static socket_ports_t gsock;
    64 
    65 static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
    6662
    6763void tcp_sock_init(void)
    … …  
    9995{
    10096        tcp_sockdata_t *sock;
    101         socket_core_t *sock_core;
    10297        int sock_id;
    10398        int rc;
    … …  
    111106        }
    112107
    113         fibril_mutex_initialize(&sock->lock);
    114108        sock->client = client;
    115109        sock->laddr.ipv4 = TCP_IPV4_ANY;
    116         sock->lconn = NULL;
    117         sock->backlog = 0;
    118         list_initialize(&sock->ready);
    119110
    120111        sock_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    124115                return;
    125116        }
    126 
    127         sock_core = socket_cores_find(&client->sockets, sock_id);
    128         assert(sock_core != NULL);
    129         sock->sock_core = sock_core;
    130117
    131118        refresh_answer(&answer, NULL);
    … …  
    180167        socket_core_t *sock_core;
    181168        tcp_sockdata_t *socket;
    182         tcp_error_t trc;
    183         tcp_sock_t lsocket;
    184         tcp_sock_t fsocket;
    185         tcp_conn_t *conn;
    186         tcp_sock_lconn_t *lconn;
    187         int i;
    188169
    189170        log_msg(LVL_DEBUG, "tcp_sock_listen()");
    … …  
    196177                return;
    197178        }
    198 
    199         if (backlog > MAX_BACKLOG)
    200                 backlog = MAX_BACKLOG;
    201179
    202180        sock_core = socket_cores_find(&client->sockets, socket_id);
    … …  
    209187
    210188        /*
    211          * Prepare @c backlog listening connections.
     189         * XXX We do not do anything and defer action to accept().
     190         * This is a slight difference in semantics, but most servers
     191         * would just listen() and immediately accept() in a loop.
     192         *
     193         * The only difference is that there is a window between
     194         * listen() and accept() or two accept()s where we refuse
     195         * connections.
    212196         */
    213         fibril_mutex_lock(&socket->lock);
    214 
    215         socket->backlog = backlog;
    216         socket->lconn = calloc(sizeof(tcp_conn_t *), backlog);
    217         if (socket->lconn == NULL) {
    218                 fibril_mutex_unlock(&socket->lock);
    219                 async_answer_0(callid, ENOMEM);
    220                 return;
    221         }
    222 
    223         log_msg(LVL_DEBUG, " - open connections");
    224 
    225         lsocket.addr.ipv4 = TCP_IPV4_ANY;
    226         lsocket.port = sock_core->port;
    227         fsocket.addr.ipv4 = TCP_IPV4_ANY;
    228         fsocket.port = TCP_PORT_ANY;
    229 
    230         for (i = 0; i < backlog; i++) {
    231 
    232                 lconn = calloc(sizeof(tcp_sock_lconn_t), 1);
    233                 if (lconn == NULL) {
    234                         /* XXX Clean up */
    235                         fibril_mutex_unlock(&socket->lock);
    236                         async_answer_0(callid, ENOMEM);
    237                         return;
    238                 }
    239 
    240                 trc = tcp_uc_open(&lsocket, &fsocket, ap_passive,
    241                     tcp_open_nonblock, &conn);
    242                 if (conn == NULL) {
    243                         /* XXX Clean up */
    244                         fibril_mutex_unlock(&socket->lock);
    245                         async_answer_0(callid, ENOMEM);
    246                         return;
    247                 }
    248 
    249                 tcp_uc_set_cstate_cb(conn, tcp_sock_cstate_cb, lconn);
    250 
    251                 assert(trc == TCP_EOK);
    252                 conn->name = (char *)"S";
    253 
    254                 lconn->conn = conn;
    255                 lconn->socket = socket;
    256                 link_initialize(&lconn->ready_list);
    257                 socket->lconn[i] = lconn;
    258         }
    259 
    260         fibril_mutex_unlock(&socket->lock);
     197        (void)backlog;
     198        (void)socket;
     199
    261200        async_answer_0(callid, EOK);
     201        log_msg(LVL_DEBUG, "tcp_sock_listen(): notify data\n");
     202        /* Push one accept notification to client's queue */
     203        tcp_sock_notify_aconn(sock_core);
    262204}
    263205
    … …  
    306248        }
    307249
    308         fibril_mutex_lock(&socket->lock);
    309 
    310250        if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
    311251                /* Find route to determine local IP address. */
    … …  
    314254                    (void **)&phdr, &phdr_len);
    315255                if (rc != EOK) {
    316                         fibril_mutex_unlock(&socket->lock);
    317256                        async_answer_0(callid, rc);
    318257                        log_msg(LVL_DEBUG, "tcp_transmit_connect: Failed to find route.");
    … …  
    330269        fsocket.port = uint16_t_be2host(addr->sin_port);
    331270
    332         trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
     271        trc = tcp_uc_open(&lsocket, &fsocket, ap_active, &socket->conn);
    333272
    334273        if (socket->conn != NULL)
    335274                socket->conn->name = (char *)"C";
    336 
    337         fibril_mutex_unlock(&socket->lock);
    338275
    339276        switch (trc) {
    … …  
    368305        tcp_sock_t fsocket;
    369306        tcp_conn_t *conn;
    370         tcp_conn_t *rconn;
    371         tcp_sock_lconn_t *lconn;
    372307        int rc;
    373308
    … …  
    384319
    385320        socket = (tcp_sockdata_t *)sock_core->specific_data;
    386         fibril_mutex_lock(&socket->lock);
    387321
    388322        log_msg(LVL_DEBUG, " - verify socket->conn");
    389323        if (socket->conn != NULL) {
    390                 fibril_mutex_unlock(&socket->lock);
    391324                async_answer_0(callid, EINVAL);
    392325                return;
    393326        }
    394327
    395         if (list_empty(&socket->ready)) {
    396                 fibril_mutex_unlock(&socket->lock);
    397                 async_answer_0(callid, ENOENT);
    398                 return;
    399         }
    400 
    401         lconn = list_get_instance(list_first(&socket->ready),
    402             tcp_sock_lconn_t, ready_list);
    403         list_remove(&lconn->ready_list);
    404 
    405         conn = lconn->conn;
    406         tcp_uc_set_cstate_cb(conn, NULL, NULL);
    407 
    408         /* Replenish listening connection */
     328        log_msg(LVL_DEBUG, " - open connection");
    409329
    410330        lsocket.addr.ipv4 = TCP_IPV4_ANY;
    … …  
    413333        fsocket.port = TCP_PORT_ANY;
    414334
    415         trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, tcp_open_nonblock,
    416             &rconn);
    417         if (rconn == NULL) {
    418                 /* XXX Clean up */
    419                 fibril_mutex_unlock(&socket->lock);
    420                 async_answer_0(callid, ENOMEM);
    421                 return;
    422         }
    423 
    424         tcp_uc_set_cstate_cb(rconn, tcp_sock_cstate_cb, lconn);
    425 
    426         assert(trc == TCP_EOK);
    427         rconn->name = (char *)"S";
    428 
    429         lconn->conn = rconn;
    430 
    431         /* Allocate socket for accepted connection */
     335        trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, &conn);
     336        if (conn != NULL)
     337                conn->name = (char *)"S";
     338
     339        log_msg(LVL_DEBUG, " - decode TCP return code");
     340
     341        switch (trc) {
     342        case TCP_EOK:
     343                rc = EOK;
     344                break;
     345        case TCP_ERESET:
     346                rc = ECONNABORTED;
     347                break;
     348        default:
     349                assert(false);
     350        }
     351
     352        log_msg(LVL_DEBUG, " - check TCP return code");
     353        if (rc != EOK) {
     354                async_answer_0(callid, rc);
     355                return;
     356        }
    432357
    433358        log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n");
    434359        asocket = calloc(sizeof(tcp_sockdata_t), 1);
    435360        if (asocket == NULL) {
    436                 fibril_mutex_unlock(&socket->lock);
    437361                async_answer_0(callid, ENOMEM);
    438362                return;
    439363        }
    440364
    441         fibril_mutex_initialize(&asocket->lock);
    442365        asocket->client = client;
    443366        asocket->conn = conn;
    … …  
    446369        rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
    447370        if (rc != EOK) {
    448                 fibril_mutex_unlock(&socket->lock);
    449371                async_answer_0(callid, rc);
    450372                return;
    … …  
    463385        answer_call(callid, asock_core->socket_id, &answer, 3);
    464386
     387        /* Push one accept notification to client's queue */
     388        tcp_sock_notify_aconn(sock_core);
     389
    465390        /* Push one fragment notification to client's queue */
    466         log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    467391        tcp_sock_notify_data(asock_core);
    468         fibril_mutex_unlock(&socket->lock);
     392        log_msg(LVL_DEBUG, "tcp_sock_accept(): notify aconn\n");
    469393}
    470394
    … …  
    495419
    496420        socket = (tcp_sockdata_t *)sock_core->specific_data;
    497         fibril_mutex_lock(&socket->lock);
    498 
    499421        if (socket->conn == NULL) {
    500                 fibril_mutex_unlock(&socket->lock);
    501422                async_answer_0(callid, ENOTCONN);
    502423                return;
    … …  
    505426        for (index = 0; index < fragments; index++) {
    506427                if (!async_data_write_receive(&wcallid, &length)) {
    507                         fibril_mutex_unlock(&socket->lock);
    508428                        async_answer_0(callid, EINVAL);
    509429                        return;
    … …  
    515435                rc = async_data_write_finalize(wcallid, buffer, length);
    516436                if (rc != EOK) {
    517                         fibril_mutex_unlock(&socket->lock);
    518437                        async_answer_0(callid, rc);
    519438                        return;
    … …  
    540459
    541460                if (rc != EOK) {
    542                         fibril_mutex_unlock(&socket->lock);
    543461                        async_answer_0(callid, rc);
    544462                        return;
    … …  
    549467        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    550468        answer_call(callid, EOK, &answer, 2);
    551         fibril_mutex_unlock(&socket->lock);
    552469}
    553470
    … …  
    587504
    588505        socket = (tcp_sockdata_t *)sock_core->specific_data;
    589         fibril_mutex_lock(&socket->lock);
    590 
    591506        if (socket->conn == NULL) {
    592                 fibril_mutex_unlock(&socket->lock);
    593507                async_answer_0(callid, ENOTCONN);
    594508                return;
    … …  
    618532        log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
    619533        if (rc != EOK) {
    620                 fibril_mutex_unlock(&socket->lock);
    621534                async_answer_0(callid, rc);
    622535                return;
    … …  
    632545                log_msg(LVL_DEBUG, "addr read receive");
    633546                if (!async_data_read_receive(&rcallid, &addr_length)) {
    634                         fibril_mutex_unlock(&socket->lock);
    635547                        async_answer_0(callid, EINVAL);
    636548                        return;
    … …  
    643555                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    644556                if (rc != EOK) {
    645                         fibril_mutex_unlock(&socket->lock);
    646557                        async_answer_0(callid, EINVAL);
    647558                        return;
    … …  
    651562        log_msg(LVL_DEBUG, "data read receive");
    652563        if (!async_data_read_receive(&rcallid, &length)) {
    653                 fibril_mutex_unlock(&socket->lock);
    654564                async_answer_0(callid, EINVAL);
    655565                return;
    … …  
    670580        /* Push one fragment notification to client's queue */
    671581        tcp_sock_notify_data(sock_core);
    672         fibril_mutex_unlock(&socket->lock);
    673582}
    674583
    … …  
    694603
    695604        socket = (tcp_sockdata_t *)sock_core->specific_data;
    696         fibril_mutex_lock(&socket->lock);
    697605
    698606        if (socket->conn != NULL) {
    699607                trc = tcp_uc_close(socket->conn);
    700608                if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
    701                         fibril_mutex_unlock(&socket->lock);
    702609                        async_answer_0(callid, EBADF);
    703610                        return;
    … …  
    716623            tcp_free_sock_data);
    717624        if (rc != EOK) {
    718                 fibril_mutex_unlock(&socket->lock);
    719625                async_answer_0(callid, rc);
    720626                return;
    721627        }
    722628
    723         fibril_mutex_unlock(&socket->lock);
    724629        async_answer_0(callid, EOK);
    725630}
    … …  
    735640        log_msg(LVL_DEBUG, "tcp_sock_setsockopt()");
    736641        async_answer_0(callid, ENOTSUP);
    737 }
    738 
    739 /** Called when connection state changes. */
    740 static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg)
    741 {
    742         tcp_conn_status_t cstatus;
    743         tcp_sock_lconn_t *lconn = (tcp_sock_lconn_t *)arg;
    744         tcp_sockdata_t *socket = lconn->socket;
    745 
    746         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()");
    747         fibril_mutex_lock(&socket->lock);
    748         assert(conn == lconn->conn);
    749 
    750         tcp_uc_status(conn, &cstatus);
    751         if (cstatus.cstate != st_established) {
    752                 fibril_mutex_unlock(&socket->lock);
    753                 return;
    754         }
    755 
    756         assert_link_not_used(&lconn->ready_list);
    757         list_append(&lconn->ready_list, &socket->ready);
    758 
    759         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
    760 
    761         /* Push one accept notification to client's queue */
    762         tcp_sock_notify_aconn(socket->sock_core);
    763         fibril_mutex_unlock(&socket->lock);
    764642}
    765643

  • uspace/srv/net/tl/tcp/tcp_type.h

    recf823a r3819ce5  
    152152} acpass_t;
    153153
    154 typedef enum {
    155         tcp_open_nonblock = 1
    156 } tcp_open_flags_t;
    157 
    158 typedef struct tcp_conn tcp_conn_t;
    159 
    160 /** Connection state change callback function */
    161 typedef void (*tcp_cstate_cb_t)(tcp_conn_t *, void *);
    162 
    163 /** Connection */
    164 struct tcp_conn {
     154typedef struct tcp_conn {
    165155        char *name;
    166156        link_t link;
    167 
    168         /** Connection state change callback function */
    169         tcp_cstate_cb_t cstate_cb;
    170         /** Argument to @c cstate_cb */
    171         void *cstate_cb_arg;
    172157
    173158        /** Connection identification (local and foreign socket) */
    … …  
    248233        /** Initial receive sequence number */
    249234        uint32_t irs;
    250 };
    251 
    252 /** Data returned by Status user call */
    253 typedef struct {
    254         /** Connection state */
    255         tcp_cstate_t cstate;
     235} tcp_conn_t;
     236
     237typedef struct {
     238        unsigned dummy;
    256239} tcp_conn_status_t;
    257240
    … …  
    331314} tcp_client_t;
    332315
    333 typedef struct tcp_sockdata {
    334         /** Lock */
    335         fibril_mutex_t lock;
    336         /** Socket core */
    337         socket_core_t *sock_core;
     316typedef struct {
    338317        /** Client */
    339318        tcp_client_t *client;
    … …  
    342321        /** Local address */
    343322        netaddr_t laddr;
    344         /** Backlog size */
    345         int backlog;
    346         /** Array of listening connections, @c backlog elements */
    347         struct tcp_sock_lconn **lconn;
    348         /** List of connections (from lconn) that are ready to be accepted */
    349         list_t ready;
    350323} tcp_sockdata_t;
    351 
    352 typedef struct tcp_sock_lconn {
    353         tcp_conn_t *conn;
    354         tcp_sockdata_t *socket;
    355         int index;
    356         link_t ready_list;
    357 } tcp_sock_lconn_t;
    358 
    359324
    360325#endif

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

    recf823a r3819ce5  
    6262        fsock.addr.ipv4 = 0x7f000001;
    6363        printf("S: User open...\n");
    64         tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn);
     64        tcp_uc_open(&lsock, &fsock, ap_passive, &conn);
    6565        conn->name = (char *) "S";
    6666
    … …  
    102102        async_usleep(1000*1000*3);
    103103        printf("C: User open...\n");
    104         tcp_uc_open(&lsock, &fsock, ap_active, 0, &conn);
     104        tcp_uc_open(&lsock, &fsock, ap_active, &conn);
    105105        conn->name = (char *) "C";
    106106

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

    recf823a r3819ce5  
    5353 * @param fsock         Foreign socket
    5454 * @param acpass        Active/passive
    55  * @param oflags        Open flags
    5655 * @param conn          Connection
    5756 *
    … …  
    6665 */
    6766tcp_error_t tcp_uc_open(tcp_sock_t *lsock, tcp_sock_t *fsock, acpass_t acpass,
    68     tcp_open_flags_t oflags, tcp_conn_t **conn)
     67    tcp_conn_t **conn)
    6968{
    7069        tcp_conn_t *nconn;
    7170
    72         log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
     71        log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %p)",
    7372            lsock, fsock, acpass == ap_active ? "active" : "passive",
    74             oflags == tcp_open_nonblock ? "nonblock" : "none", conn);
     73            conn);
    7574
    7675        nconn = tcp_conn_new(lsock, fsock);
    … …  
    8079                /* Synchronize (initiate) connection */
    8180                tcp_conn_sync(nconn);
    82         }
    83 
    84         if (oflags == tcp_open_nonblock) {
    85                 *conn = nconn;
    86                 return TCP_EOK;
    8781        }
    8882
    … …  
    107101
    108102        *conn = nconn;
    109         log_msg(LVL_DEBUG, "tcp_uc_open -> %p", nconn);
    110103        return TCP_EOK;
    111104}
    … …  
    265258{
    266259        log_msg(LVL_DEBUG, "tcp_uc_status()");
    267         cstatus->cstate = conn->cstate;
    268260}
    269261
    … …  
    278270        log_msg(LVL_DEBUG, "tcp_uc_delete()");
    279271        tcp_conn_delete(conn);
    280 }
    281 
    282 void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg)
    283 {
    284         log_msg(LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
    285             conn, cb, arg);
    286 
    287         conn->cstate_cb = cb;
    288         conn->cstate_cb_arg = arg;
    289272}
    290273

  • uspace/srv/net/tl/tcp/ucall.h

    recf823a r3819ce5  
    4242 * User calls
    4343 */
    44 extern tcp_error_t tcp_uc_open(tcp_sock_t *, tcp_sock_t *, acpass_t,
    45     tcp_open_flags_t, tcp_conn_t **);
     44extern tcp_error_t tcp_uc_open(tcp_sock_t *, tcp_sock_t *, acpass_t, tcp_conn_t **);
    4645extern tcp_error_t tcp_uc_send(tcp_conn_t *, void *, size_t, xflags_t);
    4746extern tcp_error_t tcp_uc_receive(tcp_conn_t *, void *, size_t, size_t *, xflags_t *);
    … …  
    5049extern void tcp_uc_status(tcp_conn_t *, tcp_conn_status_t *);
    5150extern void tcp_uc_delete(tcp_conn_t *);
    52 extern void tcp_uc_set_cstate_cb(tcp_conn_t *, tcp_cstate_cb_t, void *);
    5351
    5452/*
Note: See TracChangeset for help on using the changeset viewer.