OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [net/] [httpd/] [v2_0/] [src/] [monitor.c] - Blame information for rev 27

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 unneback
/* =================================================================
2
 *
3
 *      monitor.c
4
 *
5
 *      An HTTP system monitor
6
 *
7
 * =================================================================
8
 * ####ECOSGPLCOPYRIGHTBEGIN####
9
 * -------------------------------------------
10
 * This file is part of eCos, the Embedded Configurable Operating
11
 * System.
12
 * Copyright (C) 2002 Nick Garnett.
13
 *
14
 * eCos is free software; you can redistribute it and/or modify it
15
 * under the terms of the GNU General Public License as published by
16
 * the Free Software Foundation; either version 2 or (at your option)
17
 * any later version.
18
 *
19
 * eCos is distributed in the hope that it will be useful, but
20
 * WITHOUT ANY WARRANTY; without even the implied warranty of
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22
 * General Public License for more details.
23
 *
24
 * You should have received a copy of the GNU General Public License
25
 * along with eCos; if not, write to the Free Software Foundation,
26
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
27
 *
28
 * As a special exception, if other files instantiate templates or
29
 * use macros or inline functions from this file, or you compile this
30
 * file and link it with other works to produce a work based on this
31
 * file, this file does not by itself cause the resulting work to be
32
 * covered by the GNU General Public License. However the source code
33
 * for this file must still be made available in accordance with
34
 * section (3) of the GNU General Public License.
35
 *
36
 * This exception does not invalidate any other reasons why a work
37
 * based on this file might be covered by the GNU General Public
38
 * License.
39
 *
40
 * -------------------------------------------
41
 * ####ECOSGPLCOPYRIGHTEND####
42
 * =================================================================
43
 * #####DESCRIPTIONBEGIN####
44
 *
45
 *  Author(s):    nickg@calivar.com
46
 *  Contributors: nickg@calivar.com
47
 *  Date:         2002-10-14
48
 *  Purpose:
49
 *  Description:
50
 *
51
 * ####DESCRIPTIONEND####
52
 *
53
 * =================================================================
54
 */
55
 
56
#include <pkgconf/system.h>
57
#include <pkgconf/isoinfra.h>
58
#include <pkgconf/net.h>
59
#include <pkgconf/httpd.h>
60
#include <pkgconf/kernel.h>
61
 
62
#include <cyg/infra/cyg_trac.h>        /* tracing macros */
63
#include <cyg/infra/cyg_ass.h>         /* assertion macros */
64
 
65
#include <cyg/httpd/httpd.h>
66
 
67
#include <cyg/kernel/kapi.h>
68
#ifdef CYGPKG_KERNEL_INSTRUMENT
69
#include <cyg/kernel/instrmnt.h>
70
#include <cyg/kernel/instrument_desc.h>
71
#endif
72
 
73
#include <unistd.h>
74
#include <ctype.h>
75
 
76
/* ================================================================= */
77
/* Include all the necessary network headers by hand. We need to do
78
 * this so that _KERNEL is correctly defined, or not, for specific
79
 * headers so we can use both the external API and get at internal
80
 * kernel structures.
81
 */
82
 
83
#define _KERNEL
84
#include <sys/param.h>
85
#undef _KERNEL
86
#include <sys/socket.h>
87
#include <sys/ioctl.h>
88
#include <sys/errno.h>
89
#include <sys/time.h>
90
 
91
#define _KERNEL
92
 
93
#include <net/if.h>
94
#include <netinet/in.h>
95
#include <netinet/ip.h>
96
#include <netinet/ip_icmp.h>
97
#include <net/route.h>
98
#include <net/if_dl.h>
99
 
100
#include <sys/protosw.h>
101
#include <netinet/in_pcb.h>
102
#include <netinet/udp.h>
103
#include <netinet/tcp.h>
104
#include <netinet/tcp_timer.h>
105
#include <netinet/ip_var.h>
106
#include <netinet/icmp_var.h>
107
#include <netinet/udp_var.h>
108
#include <netinet/tcp_var.h>
109
 
110
#include <cyg/io/eth/eth_drv_stats.h>
111
 
112
/* ================================================================= */
113
/* Use this when a thread appears to have no name.
114
 */
115
 
116
#define NULL_THREAD_NAME "----------"
117
 
118
/* ================================================================= */
119
/* Draw navigation bar
120
 *
121
 * This draws a simple table containing links to the various monitor
122
 * pages at the current position in the HTML stream.
123
 */
124
 
125
static void draw_navbar( FILE *client )
126
{
127
    html_para_begin( client, "" );
128
 
129
    html_table_begin( client, "border cellpadding=\"4\"" );
130
    {
131
        html_table_row_begin(client, "" );
132
        {
133
            html_table_data_begin( client, "" );
134
            html_image( client, "/monitor/ecos.gif", "eCos logo", "" );
135
            html_table_data_begin( client, "" );
136
            html_url( client, "Threads", "/monitor/threads.html");
137
            html_table_data_begin( client, "" );
138
            html_url( client, "Interrupts", "/monitor/interrupts.html");
139
            html_table_data_begin( client, "" );
140
            html_url( client, "Memory", "/monitor/memory.html");
141
            html_table_data_begin( client, "" );
142
            html_url( client, "Network", "/monitor/network.html");
143
#ifdef CYGPKG_KERNEL_INSTRUMENT
144
            html_table_data_begin( client, "" );
145
            html_url( client, "Instrumentation", "/monitor/instrument.html");
146
#endif
147
        }
148
        html_table_row_end( client );
149
    }
150
    html_table_end( client );
151
}
152
 
153
/* ================================================================= */
154
/* Index page
155
 *
156
 * A simple introductory page matching "/monitor" and
157
 * "/monitor/index.html".
158
 */
159
 
160
static char monitor_index_blurb[] =
161
"<p>This is the eCos System Monitor. It presents a simple web monitor
162
and control interface for eCos systems.\n"
163
"<p>Use the navigation bar at the bottom of each page to explore."
164
;
165
 
166
static cyg_bool cyg_monitor_index( FILE * client, char *filename,
167
                                   char *formdata, void *arg )
168
{
169
    html_begin(client);
170
 
171
    html_head(client,"eCos System Monitor", "");
172
 
173
    html_body_begin(client,"");
174
    {
175
        html_heading(client, 2, "eCos System Monitor" );
176
 
177
        fputs( monitor_index_blurb, client );
178
 
179
        draw_navbar(client);
180
    }
181
    html_body_end(client);
182
 
183
    html_end(client);
184
 
185
    return 1;
186
}
187
 
188
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_entry,
189
                       "/monitor",
190
                       cyg_monitor_index,
191
                       NULL );
192
 
193
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_index_entry,
194
                       "/monitor/index.html",
195
                       cyg_monitor_index,
196
                       NULL );
197
 
198
/* ================================================================= */
199
/* Thread Monitor
200
 *
201
 * Uses the kapi thread info API to enumerate all the current threads
202
 * and generate a table showing their state.
203
 */
204
 
205
static cyg_bool cyg_monitor_threads( FILE * client, char *filename,
206
                                     char *formdata, void *arg )
207
{
208
 
209
    html_begin(client);
210
 
211
/*    html_head(client,"Thread Monitor", "<meta http-equiv=\"refresh\" content=\"10\">"); */
212
    html_head(client,"eCos Thread Monitor", "");
213
 
214
    html_body_begin(client,"");
215
    {
216
        html_heading(client, 2, "Thread Monitor" );
217
 
218
        html_table_begin( client, "border" );
219
        {
220
            cyg_handle_t thread = 0;
221
            cyg_uint16 id = 0;
222
 
223
            html_table_header( client, "Id", "" );
224
            html_table_header( client, "State", "" );
225
            html_table_header( client, "Set<br>Priority", "" );
226
            html_table_header( client, "Current<br>Priority", "" );
227
            html_table_header( client, "Name", "" );
228
            html_table_header( client, "Stack Base", "" );
229
            html_table_header( client, "Stack Size", "" );
230
#ifdef CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT
231
            html_table_header( client, "Stack Used", "" );
232
#endif
233
            /* Loop over the threads, and generate a table row for
234
             * each.
235
             */
236
            while( cyg_thread_get_next( &thread, &id ) )
237
            {
238
                cyg_thread_info info;
239
                char *state_string;
240
 
241
                cyg_thread_get_info( thread, id, &info );
242
 
243
                if( info.name == NULL )
244
                    info.name = NULL_THREAD_NAME;
245
 
246
                /* Translate the state into a string.
247
                 */
248
                if( info.state == 0 )
249
                    state_string = "RUN";
250
                else if( info.state & 0x04 )
251
                    state_string = "SUSP";
252
                else switch( info.state & 0x1b )
253
                {
254
                case 0x01: state_string = "SLEEP"; break;
255
                case 0x02: state_string = "CNTSLEEP"; break;
256
                case 0x08: state_string = "CREATE"; break;
257
                case 0x10: state_string = "EXIT"; break;
258
                default: state_string = "????"; break;
259
                }
260
 
261
                /* Now generate the row.
262
                 */
263
                html_table_row_begin(client, "" );
264
                {
265
                    html_table_data_begin( client, "" );
266
                    fprintf( client, "<a href=\"/monitor/thread-%04x.html\">%04x</a>\n", id,id);
267
                    html_table_data_begin( client, "" );
268
                    fprintf( client, "%s", state_string);
269
                    html_table_data_begin( client, "" );
270
                    fprintf( client, "%d", info.set_pri);
271
                    html_table_data_begin( client, "" );
272
                    fprintf( client, "%d", info.cur_pri);
273
                    html_table_data_begin( client, "" );
274
                    fputs( info.name, client );
275
                    html_table_data_begin( client, "" );
276
                    fprintf( client, "%08x", info.stack_base );
277
                    html_table_data_begin( client, "" );
278
                    fprintf( client, "%d", info.stack_size );
279
#ifdef CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT
280
                    html_table_data_begin( client, "" );
281
                    fprintf( client, "%d", info.stack_used );
282
#endif
283
                }
284
                html_table_row_end(client);
285
 
286
            }
287
        }
288
        html_table_end( client );
289
 
290
        draw_navbar(client);
291
    }
292
    html_body_end(client);
293
 
294
    html_end(client);
295
 
296
    return 1;
297
}
298
 
299
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_show_threads,
300
                       "/monitor/threads.htm*",
301
                       cyg_monitor_threads,
302
                       NULL );
303
 
304
/* ================================================================= */
305
/* Thread edit page
306
 *
307
 * A page on which the thread's state may be edited. This tests forms
308
 * handling.
309
 */
310
 
311
static char thread_edit_blurb[] =
312
"<p>This table contains an entry for each property of the thread
313
that you can edit. The properties are:\n"
314
"<p><b>State:</b> Change thread's state. The <em>Suspend</em> button
315
will suspend the thread. The <em>Run</em> button will undo any previous
316
suspends. The <em>Release</em> button will release the thread out of
317
any sleep it is currently in.\n"
318
"<p><b>Priority:</b> Change the thread's priority.\n"
319
"<p>Once the new state has been selected, press the <em>Submit</em>
320
button to make the change, or <em>Reset</em> to clear it."
321
;
322
 
323
static cyg_bool cyg_monitor_thread_edit( FILE * client, char *filename,
324
                                         char *formdata, void *arg )
325
{
326
    /* If any form data has been supplied, then change the thread's
327
     * state accordingly.
328
     */
329
    if( formdata != NULL )
330
    {
331
        char *formlist[6];
332
        char *state;
333
        char *pri_string;
334
        char *id_string;
335
        cyg_handle_t thread = 0;
336
        cyg_uint16 id;
337
 
338
        /* Parse the data */
339
        cyg_formdata_parse( formdata, formlist, 6 );
340
 
341
        /* Get the thread id from the hidden control */
342
        id_string = cyg_formlist_find( formlist, "thread");
343
 
344
        sscanf( id_string, "%04hx", &id );
345
 
346
        thread = cyg_thread_find( id );
347
 
348
        /* If there is a pri field, change the priority */
349
        pri_string = cyg_formlist_find( formlist, "pri");
350
 
351
        if( pri_string != NULL )
352
        {
353
            cyg_priority_t pri;
354
 
355
            sscanf( pri_string, "%d", &pri );
356
 
357
            cyg_thread_set_priority( thread, pri );
358
        }
359
 
360
        /* If there is a state field, change the thread state */
361
        state = cyg_formlist_find( formlist, "state");
362
 
363
        if( state != NULL )
364
        {
365
            if( strcmp( state, "run" ) == 0 )
366
                cyg_thread_resume( thread );
367
            if( strcmp( state, "suspend" ) == 0 )
368
                cyg_thread_suspend( thread );
369
            if( strcmp( state, "release" ) == 0 )
370
                cyg_thread_release( thread );
371
        }
372
    }
373
 
374
    /* Now generate a page showing the current thread state, and
375
     * including form controls to change it.
376
     */
377
 
378
    html_begin(client);
379
 
380
    html_head(client,"eCos Thread Editor", "");
381
 
382
    html_body_begin(client,"");
383
    {
384
        cyg_uint16 id;
385
        cyg_thread_info info;
386
        cyg_handle_t thread = 0;
387
        char idbuf[16];
388
 
389
        sscanf( filename, "/monitor/thread-%04hx.html", &id );
390
 
391
        thread = cyg_thread_find( id );
392
        cyg_thread_get_info(thread, id, &info );
393
 
394
        html_heading(client, 2, "Thread State Editor" );
395
 
396
        html_para_begin( client, "" );
397
 
398
        fprintf( client, "Editing Thread %04x %s\n",id,
399
                 info.name?info.name:NULL_THREAD_NAME);
400
 
401
        fputs( thread_edit_blurb, client );
402
 
403
        html_form_begin( client, filename, "" );
404
        {
405
            html_table_begin( client, "border" );
406
            {
407
                html_table_header( client, "Property", "" );
408
                html_table_header( client, "Value", "" );
409
 
410
                html_table_row_begin(client, "" );
411
                {
412
                    html_table_data_begin( client, "" );
413
                    fputs( "State", client );
414
 
415
                    html_table_data_begin( client, "" );
416
 
417
                    html_form_input_radio( client, "state", "run", (info.state&0x04)==0 );
418
                    fputs( "Run", client );
419
                    html_form_input_radio( client, "state", "suspend", (info.state&0x04)!=0 );
420
                    fputs( "Suspend", client );
421
                    html_form_input_radio( client, "state", "release", 0 );
422
                    fputs( "Release", client );
423
                }
424
                html_table_row_end( client );
425
 
426
                html_table_row_begin(client, "" );
427
                {
428
                    html_table_data_begin( client, "" );
429
                    fputs( "Priority", client );
430
 
431
                    html_table_data_begin( client, "" );
432
                    fprintf(client,"<input type=\"text\" name=\"pri\" size=\"10\" value=\"%d\">\n",
433
                            info.set_pri);
434
                }
435
                html_table_row_end( client );
436
 
437
            }
438
            html_table_end( client );
439
 
440
            /* Add submit and reset buttons */
441
            html_form_input(client, "submit", "submit", "Submit", "");
442
            html_form_input(client, "reset", "reset", "Reset", "");
443
 
444
            /* Pass the thread ID through to our next incarnation */
445
            sprintf( idbuf, "%04x", id );
446
            html_form_input_hidden(client, "thread", idbuf );
447
 
448
        }
449
        html_form_end( client );
450
 
451
        draw_navbar(client);
452
    }
453
    html_body_end(client);
454
 
455
    html_end(client);
456
 
457
    return 1;
458
}
459
 
460
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_thread_edit_entry,
461
                       "/monitor/thread-*",
462
                       cyg_monitor_thread_edit,
463
                       NULL );
464
 
465
/* ================================================================= */
466
/* Interrupt monitor
467
 *
468
 * At present this just generates a table showing which interrupts
469
 * have an ISR attached.
470
 */
471
 
472
static cyg_bool cyg_monitor_interrupts( FILE * client, char *filename,
473
                                        char *formdata, void *arg )
474
{
475
    html_begin(client);
476
 
477
    html_head(client,"eCos Interrupt Monitor", "");
478
 
479
    html_body_begin(client,"");
480
    {
481
        html_heading(client, 2, "Interrupt Monitor" );
482
 
483
        html_table_begin( client, "border" );
484
        {
485
            int i;
486
            int maxint = CYGNUM_HAL_ISR_MAX;
487
 
488
#ifdef CYGPKG_HAL_I386
489
            maxint = CYGNUM_HAL_ISR_MIN+16;
490
#endif
491
 
492
            html_table_header( client, "ISR", "" );
493
            html_table_header( client, "State", "" );
494
 
495
            for( i = CYGNUM_HAL_ISR_MIN; i <= maxint ; i++ )
496
            {
497
                cyg_bool_t inuse;
498
                HAL_INTERRUPT_IN_USE( i, inuse );
499
 
500
                html_table_row_begin(client, "" );
501
                {
502
                    html_table_data_begin( client, "" );
503
                    fprintf( client, "%d", i);
504
                    html_table_data_begin( client, "" );
505
                    fprintf( client, "%s", inuse?"In Use":"Free");
506
                }
507
                html_table_row_end( client );
508
            }
509
        }
510
        html_table_end( client );
511
 
512
        draw_navbar(client);
513
    }
514
    html_body_end(client);
515
 
516
    html_end(client);
517
 
518
    return 1;
519
 
520
}
521
 
522
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_interrupts_entry,
523
                       "/monitor/interrupts.htm*",
524
                       cyg_monitor_interrupts,
525
                       NULL );
526
 
527
/* ================================================================= */
528
/* Memory monitor
529
 *
530
 * Generates a table showing a 256 byte page of memory. Form controls
531
 * allow changes to the base address and display element size.
532
 */
533
 
534
static cyg_bool cyg_monitor_memory( FILE * client, char *filename,
535
                                    char *formdata, void *arg )
536
{
537
    char *formlist[10];
538
    cyg_uint32 base = 0;
539
    unsigned int datasize = 1;
540
    int size = 256;
541
    char *p;
542
 
543
    cyg_formdata_parse( formdata, formlist, 10 );
544
 
545
    p = cyg_formlist_find( formlist, "base" );
546
 
547
    if( p != NULL )
548
        sscanf( p, "%x", &base );
549
 
550
    p = cyg_formlist_find( formlist, "datasize" );
551
 
552
    if( p != NULL )
553
        sscanf( p, "%x", &datasize );
554
 
555
    if( cyg_formlist_find( formlist, "next" ) != NULL )
556
        base += size;
557
 
558
    if( cyg_formlist_find( formlist, "prev" ) != NULL )
559
        base -= size;
560
 
561
    html_begin(client);
562
 
563
    html_head(client,"eCos Memory Monitor", "");
564
 
565
    html_body_begin(client,"");
566
    {
567
        html_heading(client, 2, "Memory Monitor" );
568
 
569
        html_form_begin( client, "/monitor/memory.html", "" );
570
        {
571
 
572
            /* Text input control for base address
573
             */
574
            html_para_begin( client, "" );
575
            fprintf(client,
576
                    "Base Address: 0x<input type=\"text\" name=\"base\" size=\"10\" value=\"%x\">\n",
577
                    base);
578
 
579
            /* A little menu for the element size
580
             */
581
            html_para_begin( client, "" );
582
 
583
            fputs( "Element Size: ", client );
584
            html_form_select_begin( client, "datasize", "" );
585
            html_form_option( client, "1", "bytes", datasize==1 );
586
            html_form_option( client, "2", "words", datasize==2 );
587
            html_form_option( client, "4", "dwords", datasize==4 );
588
            html_form_select_end( client );
589
 
590
            html_para_begin( client, "" );
591
 
592
            /* Submit and reset buttons
593
             */
594
            html_form_input(client, "submit", "submit", "Submit", "");
595
            html_form_input(client, "reset", "reset", "Reset", "");
596
 
597
            html_para_begin( client, "" );
598
 
599
            /* Previous page button */
600
            html_form_input(client, "submit", "prev", "Prev Page", "");
601
 
602
            /* Switch to monospaced font */
603
            cyg_html_tag_begin( client, "font", "face=\"monospace\"" );
604
 
605
            html_table_begin( client, "" );
606
            {
607
                cyg_addrword_t loc;
608
                cyg_addrword_t oloc;
609
 
610
                for( oloc = loc = base; loc <= (base+size) ; loc++ )
611
                {
612
                    if( ( loc % 16 ) == 0 )
613
                    {
614
                        if( loc != base )
615
                        {
616
                            html_table_data_begin( client, "" );
617
                            for( ; oloc < loc; oloc++ )
618
                            {
619
                                char c = *(char *)oloc;
620
                                if( !isprint(c) )
621
                                    c = '.';
622
                                putc( c, client );
623
                            }
624
                            html_table_row_end( client );
625
                        }
626
                        if( loc == (base+size) )
627
                            break;
628
                        html_table_row_begin(client, "" );
629
                        html_table_data_begin( client, "" );
630
                        fprintf( client, "%08x:",loc);
631
                    }
632
 
633
                    html_table_data_begin( client, "" );
634
 
635
                    if( (loc % datasize) == 0 )
636
                    {
637
                        switch( datasize )
638
                        {
639
                        case 1: fprintf( client, "%02x", *(cyg_uint8  *)loc ); break;
640
                        case 2: fprintf( client, "%04x", *(cyg_uint16 *)loc ); break;
641
                        case 4: fprintf( client, "%08x", *(cyg_uint32 *)loc ); break;
642
                        }
643
                    }
644
                }
645
            }
646
            html_table_end( client );
647
            cyg_html_tag_end( client, "font" );
648
 
649
            html_form_input(client, "submit", "next", "Next Page", "");
650
        }
651
        html_form_end( client );
652
 
653
        draw_navbar(client);
654
    }
655
    html_body_end(client);
656
 
657
    html_end(client);
658
 
659
    return 1;
660
 
661
}
662
 
663
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_memory_entry,
664
                       "/monitor/memory.htm*",
665
                       cyg_monitor_memory,
666
                       NULL );
667
 
668
/* ================================================================= */
669
/* Network Monitor
670
 *
671
 * This function generates a page containing information about the
672
 * network interfaces and the protocols.
673
 */
674
 
675
static cyg_bool cyg_monitor_network( FILE * client, char *filename,
676
                                     char *formdata, void *arg )
677
{
678
    struct ifconf ifconf;
679
    char conf[256];
680
    int err;
681
    int sock;
682
 
683
    /* Start by opening a socket and getting a list of all the
684
     * interfaces present.
685
     */
686
    {
687
        memset( conf, 0, sizeof(conf) );
688
 
689
        sock = socket( AF_INET, SOCK_DGRAM, 0 );
690
 
691
        ifconf.ifc_len = sizeof(conf);
692
        ifconf.ifc_buf = (caddr_t)conf;
693
 
694
        err = ioctl( sock, SIOCGIFCONF, &ifconf );
695
    }
696
 
697
    html_begin(client);
698
 
699
    html_head(client,"eCos Network Monitor", "");
700
 
701
    html_body_begin(client,"");
702
    {
703
        html_heading(client, 2, "Network Monitor" );
704
 
705
        html_heading(client, 3, "Interfaces" );
706
 
707
        html_table_begin( client, "border" );
708
        {
709
            int i;
710
            struct ifreq *ifrp;
711
            struct sockaddr *sa;
712
 
713
            html_table_header( client, "Interface", "" );
714
            html_table_header( client, "Status", "" );
715
 
716
            ifrp = ifconf.ifc_req;
717
 
718
            while( ifconf.ifc_len && ifrp->ifr_name[0] )
719
            {
720
                struct ifreq ifreq = *ifrp;
721
 
722
                /* For some reason we get two entries for each
723
                 * interface in the list: one with an AF_INET address
724
                 * and one with an AF_LINK address. We are currently
725
                 * only interested in the AF_INET ones.
726
                 */
727
 
728
                if( ifrp->ifr_addr.sa_family == AF_INET )
729
                {
730
 
731
                    html_table_row_begin(client, "" );
732
                    {
733
                        html_table_data_begin( client, "" );
734
                        fprintf( client, "%s", ifrp->ifr_name);
735
 
736
                        html_table_data_begin( client, "" );
737
                        html_table_begin( client, "" );
738
                        {
739
                            struct ether_drv_stats ethstats;
740
 
741
                            /* Get the interface's flags and display
742
                             * the interesting ones.
743
                             */
744
 
745
                            if( ioctl( sock, SIOCGIFFLAGS, &ifreq ) >= 0 )
746
                            {
747
                                html_table_row_begin(client, "" );
748
                                fprintf( client, "<td>Flags<td>\n" );
749
                                for( i = 0; i < 16; i++ )
750
                                {
751
                                    switch( ifreq.ifr_flags & (1<<i) )
752
                                    {
753
                                    default: break;
754
                                    case IFF_UP: fputs( " UP", client ); break;
755
                                    case IFF_BROADCAST: fputs( " BROADCAST", client ); break;
756
                                    case IFF_DEBUG: fputs( " DEBUG", client ); break;
757
                                    case IFF_LOOPBACK: fputs( " LOOPBACK", client ); break;
758
                                    case IFF_PROMISC: fputs( " PROMISCUOUS", client ); break;
759
                                    case IFF_RUNNING: fputs( " RUNNING", client ); break;
760
                                    case IFF_SIMPLEX: fputs( " SIMPLEX", client ); break;
761
                                    case IFF_MULTICAST: fputs( " MULTICAST", client ); break;
762
                                    }
763
                                }
764
                                html_table_row_end( client );
765
                            }
766
 
767
                            /* Get the interface's address and display it. */
768
                            if( ioctl( sock, SIOCGIFADDR, &ifreq ) >= 0 )
769
                            {
770
                                struct sockaddr_in *inaddr =
771
                                    (struct sockaddr_in *)&ifreq.ifr_addr;
772
 
773
                                html_table_row_begin(client, "" );
774
                                fprintf( client, "<td>Address<td>%s\n",
775
                                         inet_ntoa(inaddr->sin_addr));
776
                                html_table_row_end( client );
777
                            }
778
 
779
                            /* If there's a netmask, show that. */
780
                            if( ioctl( sock, SIOCGIFNETMASK, &ifreq ) >= 0 )
781
                            {
782
                                struct sockaddr_in *inaddr =
783
                                    (struct sockaddr_in *)&ifreq.ifr_addr;
784
 
785
                                html_table_row_begin(client, "" );
786
                                fprintf( client, "<td>Mask<td>%s\n",
787
                                         inet_ntoa(inaddr->sin_addr));
788
                                html_table_row_end( client );
789
                            }
790
 
791
                            /* If there's a broadcast address, show that. */
792
                            if( ioctl( sock, SIOCGIFBRDADDR, &ifreq ) >= 0 )
793
                            {
794
                                struct sockaddr_in *inaddr =
795
                                    (struct sockaddr_in *)&ifreq.ifr_broadaddr;
796
 
797
                                html_table_row_begin(client, "" );
798
                                fprintf( client, "<td>Broadcast Address<td>%s\n",
799
                                         inet_ntoa(inaddr->sin_addr));
800
                                html_table_row_end( client );
801
                            }
802
 
803
                            /* If the ethernet driver collects
804
                             * statistics, fetch those and show some
805
                             * of them.
806
                             */
807
 
808
                            ethstats.ifreq = ifreq;
809
                            if( ioctl( sock, SIOCGIFSTATS, &ethstats ) >= 0 )
810
                            {
811
                                fprintf( client, "<tr><td>Hardware<td>%s</tr>\n",
812
                                         ethstats.description );
813
                                fprintf( client, "<tr><td>Packets Received<td>%d</tr>\n",
814
                                         ethstats.rx_count );
815
                                fprintf( client, "<tr><td>Packets Sent<td>%d</tr>\n",
816
                                         ethstats.tx_count );
817
                                fprintf( client, "<tr><td>Interrupts<td>%d</tr>\n",
818
                                         ethstats.interrupts );
819
                            }
820
                        }
821
                        html_table_end( client );
822
                    }
823
                    html_table_row_end( client );
824
 
825
                }
826
 
827
                /* Scan the addresses, even if we are not interested
828
                 * in this interface, since we must skip to the next.
829
                 */
830
                do
831
                {
832
                    sa = &ifrp->ifr_addr;
833
                    if (sa->sa_len <= sizeof(*sa)) {
834
                        ifrp++;
835
                    } else {
836
                        ifrp=(struct ifreq *)(sa->sa_len + (char *)sa);
837
                        ifconf.ifc_len -= sa->sa_len - sizeof(*sa);
838
                    }
839
                    ifconf.ifc_len -= sizeof(*ifrp);
840
 
841
                } while (!ifrp->ifr_name[0] && ifconf.ifc_len);
842
            }
843
        }
844
        html_table_end( client );
845
 
846
        /* Now the protocols. For each of the main protocols: IP,
847
         * ICMP, UDP, TCP print a table of useful information derived
848
         * from the in-kernel data structures. Note that this only
849
         * works for the BSD stacks.
850
         */
851
 
852
        html_para_begin( client, "" );
853
        html_heading(client, 3, "Protocols" );
854
 
855
        html_para_begin( client, "" );
856
        html_table_begin( client, "border");
857
        {
858
            html_table_header( client, "IP", "" );
859
            html_table_header( client, "ICMP", "" );
860
            html_table_header( client, "UDP", "" );
861
            html_table_header( client, "TCP", "" );
862
 
863
            html_table_row_begin(client, "" );
864
            {
865
                html_table_data_begin( client, "valign=\"top\"" );
866
                html_table_begin( client, "" );
867
                {
868
 
869
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Received" );
870
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Total",
871
                             ipstat.ips_total );
872
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Bad",
873
                             ipstat.ips_badsum+
874
                             ipstat.ips_tooshort+
875
                             ipstat.ips_toosmall+
876
                             ipstat.ips_badhlen+
877
                             ipstat.ips_badlen+
878
                             ipstat.ips_noproto+
879
                             ipstat.ips_toolong
880
                        );
881
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Reassembled",
882
                             ipstat.ips_reassembled );
883
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Delivered",
884
                             ipstat.ips_delivered );
885
 
886
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Sent" );
887
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Total",
888
                             ipstat.ips_localout );
889
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Raw",
890
                             ipstat.ips_rawout );
891
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Fragmented",
892
                             ipstat.ips_fragmented );
893
 
894
                }
895
                html_table_end( client );
896
 
897
                html_table_data_begin( client, "valign=\"top\"" );
898
                html_table_begin( client, "" );
899
                {
900
 
901
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Received" );
902
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "ECHO",
903
                             icmpstat.icps_inhist[ICMP_ECHO] );
904
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "ECHO REPLY",
905
                             icmpstat.icps_inhist[ICMP_ECHOREPLY] );
906
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "UNREACH",
907
                             icmpstat.icps_inhist[ICMP_UNREACH] );
908
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "REDIRECT",
909
                             icmpstat.icps_inhist[ICMP_REDIRECT] );
910
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Other",
911
                             icmpstat.icps_inhist[ICMP_SOURCEQUENCH]+
912
                             icmpstat.icps_inhist[ICMP_ROUTERADVERT]+
913
                             icmpstat.icps_inhist[ICMP_ROUTERSOLICIT]+
914
                             icmpstat.icps_inhist[ICMP_TIMXCEED]+
915
                             icmpstat.icps_inhist[ICMP_PARAMPROB]+
916
                             icmpstat.icps_inhist[ICMP_TSTAMP]+
917
                             icmpstat.icps_inhist[ICMP_TSTAMPREPLY]+
918
                             icmpstat.icps_inhist[ICMP_IREQ]+
919
                             icmpstat.icps_inhist[ICMP_IREQREPLY]+
920
                             icmpstat.icps_inhist[ICMP_MASKREQ]+
921
                             icmpstat.icps_inhist[ICMP_MASKREPLY]
922
                        );
923
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Bad",
924
                             icmpstat.icps_badcode+
925
                             icmpstat.icps_tooshort+
926
                             icmpstat.icps_checksum+
927
                             icmpstat.icps_badlen+
928
                             icmpstat.icps_bmcastecho
929
                        );
930
 
931
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Sent" );
932
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "ECHO",
933
                             icmpstat.icps_outhist[ICMP_ECHO] );
934
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "ECHO REPLY",
935
                             icmpstat.icps_outhist[ICMP_ECHOREPLY] );
936
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "UNREACH",
937
                             icmpstat.icps_outhist[ICMP_UNREACH] );
938
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "REDIRECT",
939
                             icmpstat.icps_outhist[ICMP_REDIRECT] );
940
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Other",
941
                             icmpstat.icps_inhist[ICMP_SOURCEQUENCH]+
942
                             icmpstat.icps_outhist[ICMP_ROUTERADVERT]+
943
                             icmpstat.icps_outhist[ICMP_ROUTERSOLICIT]+
944
                             icmpstat.icps_outhist[ICMP_TIMXCEED]+
945
                             icmpstat.icps_outhist[ICMP_PARAMPROB]+
946
                             icmpstat.icps_outhist[ICMP_TSTAMP]+
947
                             icmpstat.icps_outhist[ICMP_TSTAMPREPLY]+
948
                             icmpstat.icps_outhist[ICMP_IREQ]+
949
                             icmpstat.icps_outhist[ICMP_IREQREPLY]+
950
                             icmpstat.icps_outhist[ICMP_MASKREQ]+
951
                             icmpstat.icps_outhist[ICMP_MASKREPLY]
952
                        );
953
                }
954
                html_table_end( client );
955
 
956
                html_table_data_begin( client, "valign=\"top\"" );
957
                html_table_begin( client, "" );
958
                {
959
 
960
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Received" );
961
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Total",
962
                             udpstat.udps_ipackets );
963
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Bad",
964
                             udpstat.udps_hdrops+
965
                             udpstat.udps_badsum+
966
                             udpstat.udps_badlen+
967
                             udpstat.udps_noport+
968
                             udpstat.udps_noportbcast+
969
                             udpstat.udps_fullsock
970
                        );
971
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Sent" );
972
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Total",
973
                             udpstat.udps_opackets );
974
                }
975
                html_table_end( client );
976
 
977
                html_table_data_begin( client, "valign=\"top\"" );
978
                html_table_begin( client, "" );
979
                {
980
 
981
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Connections" );
982
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Initiated",
983
                             tcpstat.tcps_connattempt );
984
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Accepted",
985
                             tcpstat.tcps_accepts );
986
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Established",
987
                             tcpstat.tcps_connects );
988
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Closed",
989
                             tcpstat.tcps_closed );
990
 
991
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Received" );
992
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Packets",
993
                             tcpstat.tcps_rcvtotal );
994
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Data Packets",
995
                             tcpstat.tcps_rcvpack );
996
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Bytes",
997
                             tcpstat.tcps_rcvbyte );
998
 
999
                    fprintf( client, "<tr><td><b>%s:</b><td></tr>\n", "Sent" );
1000
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Packets",
1001
                             tcpstat.tcps_sndtotal );
1002
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Data Packets",
1003
                             tcpstat.tcps_sndpack );
1004
                    fprintf( client, "<tr><td>%s<td>%ld</tr>\n", "Bytes",
1005
                             tcpstat.tcps_sndbyte );
1006
 
1007
 
1008
                }
1009
                html_table_end( client );
1010
 
1011
 
1012
            }
1013
            html_table_row_end( client );
1014
 
1015
        }
1016
        html_table_end( client );
1017
 
1018
 
1019
        draw_navbar(client);
1020
    }
1021
    html_body_end(client);
1022
 
1023
    html_end(client);
1024
 
1025
    close( sock );
1026
 
1027
    return 1;
1028
 
1029
}
1030
 
1031
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_network_entry,
1032
                       "/monitor/network.htm*",
1033
                       cyg_monitor_network,
1034
                       NULL );
1035
 
1036
 
1037
/* ================================================================= */
1038
/* Instrumentation Monitor
1039
 *
1040
 * If the CYGPKG_KERNEL_INSTRUMENT option is set, we generate a table
1041
 * showing the current instrumentation buffer. If the FLAGS option is
1042
 * enabled we also print a table giving control of the flags.
1043
 *
1044
 */
1045
 
1046
#ifdef CYGPKG_KERNEL_INSTRUMENT
1047
 
1048
/* Instrumentation record. */
1049
struct Instrument_Record
1050
{
1051
    CYG_WORD16  type;                   // record type
1052
    CYG_WORD16  thread;                 // current thread id
1053
    CYG_WORD    timestamp;              // 32 bit timestamp
1054
    CYG_WORD    arg1;                   // first arg
1055
    CYG_WORD    arg2;                   // second arg
1056
};
1057
typedef struct Instrument_Record Instrument_Record;
1058
 
1059
/* Instrumentation variables, these live in the
1060
 * instrumentation files in the kernel
1061
 */
1062
__externC Instrument_Record       *instrument_buffer_pointer;
1063
__externC Instrument_Record       instrument_buffer[];
1064
__externC cyg_uint32              instrument_buffer_size;
1065
 
1066
#if defined(CYGDBG_KERNEL_INSTRUMENT_FLAGS) && \
1067
    defined(CYGDBG_KERNEL_INSTRUMENT_MSGS)
1068
 
1069
static cyg_uint32 instrument_flags[(CYG_INSTRUMENT_CLASS_MAX>>8)+1];
1070
 
1071
#endif
1072
 
1073
static char cyg_monitor_instrument_blurb1[] =
1074
"<p>Use the checkboxes to enable the events to be recorded. Click
1075
the <em>Submit</em> button to start recording. Click the <em>Clear</em>
1076
button to clear all instrumentation and to stop recording."
1077
;
1078
 
1079
static cyg_bool cyg_monitor_instrument( FILE * client, char *filename,
1080
                                        char *formdata, void *arg )
1081
{
1082
 
1083
#if defined(CYGDBG_KERNEL_INSTRUMENT_FLAGS) && \
1084
    defined(CYGDBG_KERNEL_INSTRUMENT_MSGS)
1085
 
1086
    /* Disable all instrumentation while we generate the page.
1087
     * Otherwise we could swamp the information we are really after.
1088
     */
1089
 
1090
    cyg_scheduler_lock();
1091
    {
1092
        struct instrument_desc_s *id = instrument_desc;
1093
        CYG_WORD cl = 0, ev = 0;
1094
 
1095
        for( ; id->msg != 0; id++ )
1096
        {
1097
            if( id->num > 0xff )
1098
            {
1099
                cl = id->num>>8;
1100
                instrument_flags[cl] = 0;
1101
            }
1102
            else
1103
            {
1104
                ev = id->num;
1105
                cyg_instrument_disable( cl<<8, ev );
1106
            }
1107
        }
1108
    }
1109
    cyg_scheduler_unlock();
1110
 
1111
#endif
1112
 
1113
    /* If we have some form data, deal with it.
1114
     */
1115
    if( formdata != NULL )
1116
    {
1117
        char *list[40];
1118
 
1119
        cyg_formdata_parse( formdata, list, sizeof(list)/sizeof(*list) );
1120
 
1121
#if defined(CYGDBG_KERNEL_INSTRUMENT_FLAGS) && \
1122
    defined(CYGDBG_KERNEL_INSTRUMENT_MSGS)
1123
 
1124
        if( cyg_formlist_find( list, "clear" ) != NULL )
1125
        {
1126
            /* If the clear button is set, then disable all instrumentation flags.
1127
             */
1128
            int i;
1129
            for( i = 0; i < sizeof(instrument_flags)/sizeof(*instrument_flags); i++ )
1130
                instrument_flags[i] = 0;
1131
        }
1132
        else
1133
        {
1134
            /* Otherwise all the set checkboxes have been reported to
1135
             * us in the form of class=event inputs.
1136
             */
1137
            char **p;
1138
            for( p = list; *p != NULL; p++ )
1139
            {
1140
                int cl,ev;
1141
                if( sscanf( *p, "%02x=%02x", &cl, &ev ) == 2 )
1142
                    instrument_flags[cl] |= 1<<ev;
1143
            }
1144
        }
1145
#endif
1146
 
1147
        /* If the cleartable button has been pressed, clear all the
1148
         * table entries.
1149
         */
1150
        if( cyg_formlist_find( list, "cleartable" ) != NULL )
1151
        {
1152
            cyg_scheduler_lock();
1153
            {
1154
                Instrument_Record *ibp = instrument_buffer_pointer;
1155
                do
1156
                {
1157
                    ibp->type = 0;
1158
                    ibp++;
1159
                    if( ibp == &instrument_buffer[instrument_buffer_size] )
1160
                        ibp = instrument_buffer;
1161
 
1162
                } while( ibp != instrument_buffer_pointer );
1163
 
1164
            }
1165
            cyg_scheduler_unlock();
1166
        }
1167
    }
1168
 
1169
    /* Now start generating the HTML page.
1170
     */
1171
    html_begin(client);
1172
 
1173
    html_head(client,"eCos Instrumentation Buffer", "");
1174
 
1175
    html_body_begin(client,"");
1176
    {
1177
        html_heading(client, 2, "Instrumentation Buffer" );
1178
 
1179
        html_form_begin( client, "/monitor/instrument.html", "" );
1180
 
1181
#if defined(CYGDBG_KERNEL_INSTRUMENT_FLAGS) && \
1182
    defined(CYGDBG_KERNEL_INSTRUMENT_MSGS)
1183
 
1184
        /* If we have the flags enabled, generate a table showing all
1185
         * the flag names with a checkbox against each.
1186
         */
1187
 
1188
        fputs( cyg_monitor_instrument_blurb1, client );
1189
 
1190
        html_para_begin( client, "" );
1191
        /* Add submit,clear and reset buttons */
1192
        html_form_input(client, "submit", "submit", "Submit", "");
1193
        html_form_input(client, "submit", "clear", "Clear", "");
1194
        html_form_input(client, "reset", "reset", "Reset", "");
1195
 
1196
        html_table_begin( client, "border width=100%" );
1197
        {
1198
            struct instrument_desc_s *id = instrument_desc;
1199
            CYG_WORD cl = 0, ev = 0;
1200
            int clc = 0;
1201
            char class[5], event[5];
1202
 
1203
            html_table_row_begin( client, "" );
1204
 
1205
            for( ; id->msg != 0; id++ )
1206
            {
1207
                if( id->num > 0xff )
1208
                {
1209
                    cl = id->num;
1210
                    sprintf( class, "%02x", cl>>8 );
1211
                    clc = 0;
1212
 
1213
                    if( id != instrument_desc )
1214
                    {
1215
                        html_table_end( client );
1216
                        html_table_row_end( client );
1217
                        html_table_row_begin( client, "" );
1218
                    }
1219
 
1220
                    html_table_data_begin( client, "valign=\"top\" width=100%" );
1221
                    html_table_begin( client, "width=100%" );
1222
                }
1223
                else
1224
                {
1225
                    ev = id->num;
1226
                    sprintf( event, "%02x", ev );
1227
 
1228
                    if( (clc%4) == 0 )
1229
                    {
1230
                        if( clc != 0 )
1231
                            html_table_row_end( client );
1232
 
1233
                        html_table_row_begin( client, "" );
1234
                    }
1235
                    clc++;
1236
                    html_table_data_begin( client, "width=25%" );
1237
                    html_form_input_checkbox( client, class, event,
1238
                                              instrument_flags[cl>>8] & (1<<ev) );
1239
                    fputs( id->msg, client );
1240
                }
1241
            }
1242
            html_table_end( client );
1243
            html_table_row_end( client );
1244
        }
1245
        html_table_end( client );
1246
 
1247
        /* Add submit,clear and reset buttons */
1248
        html_form_input(client, "submit", "submit", "Submit", "");
1249
        html_form_input(client, "submit", "clear", "Clear", "");
1250
        html_form_input(client, "reset", "reset", "Reset", "");
1251
 
1252
#endif
1253
 
1254
        html_para_begin( client, "" );
1255
 
1256
        html_form_input(client, "submit", "cleartable", "Clear Table", "");
1257
 
1258
 
1259
        /*
1260
         */
1261
 
1262
        html_table_begin( client, "border" );
1263
        {
1264
            Instrument_Record *ibp = instrument_buffer_pointer;
1265
 
1266
            html_table_header( client, "TIME", "" );
1267
            html_table_header( client, "THREAD", "" );
1268
            html_table_header( client, "EVENT", "" );
1269
            html_table_header( client, "ARG1", "" );
1270
            html_table_header( client, "ARG2", "" );
1271
 
1272
            do
1273
            {
1274
                if( ibp->type != 0 )
1275
                {
1276
                    html_table_row_begin(client, "" );
1277
                    {
1278
                        cyg_handle_t thread = cyg_thread_find(ibp->thread);
1279
                        cyg_thread_info info;
1280
 
1281
                        html_table_data_begin( client, "" );
1282
                        fprintf( client, "%08x",ibp->timestamp);
1283
                        html_table_data_begin( client, "" );
1284
                        if( thread != 0 &&
1285
                            cyg_thread_get_info( thread, ibp->thread, &info ) &&
1286
                            info.name != NULL )
1287
                            fputs( info.name, client );
1288
                        else fprintf( client, "[%04x]", ibp->thread);
1289
                        html_table_data_begin( client, "" );
1290
#if defined(CYGDBG_KERNEL_INSTRUMENT_MSGS)
1291
                        fprintf( client, "%s", cyg_instrument_msg(ibp->type));
1292
#else
1293
                        fprintf( client, "%04x", ibp->type );
1294
#endif
1295
                        html_table_data_begin( client, "" );
1296
                        fprintf( client, "%08x", ibp->arg1);
1297
                        html_table_data_begin( client, "" );
1298
                        fprintf( client, "%08x", ibp->arg2);
1299
                    }
1300
                    html_table_row_end( client );
1301
                }
1302
                ibp++;
1303
                if( ibp == &instrument_buffer[instrument_buffer_size] )
1304
                    ibp = instrument_buffer;
1305
 
1306
            } while( ibp != instrument_buffer_pointer );
1307
        }
1308
        html_table_end( client );
1309
 
1310
        html_para_begin( client, "" );
1311
 
1312
        html_form_input(client, "submit", "cleartable", "Clear Table", "");
1313
 
1314
        html_form_end( client );
1315
 
1316
        draw_navbar(client);
1317
    }
1318
    html_body_end(client);
1319
 
1320
    html_end(client);
1321
 
1322
 
1323
#if defined(CYGDBG_KERNEL_INSTRUMENT_FLAGS) && \
1324
    defined(CYGDBG_KERNEL_INSTRUMENT_MSGS)
1325
 
1326
    /*
1327
     */
1328
 
1329
    cyg_scheduler_lock();
1330
    {
1331
        struct instrument_desc_s *id = instrument_desc;
1332
        CYG_WORD cl = 0, ev = 0;
1333
 
1334
        for( ; id->msg != 0; id++ )
1335
        {
1336
            if( id->num > 0xff )
1337
                cl = id->num>>8;
1338
            else
1339
            {
1340
                ev = id->num;
1341
                if( (instrument_flags[cl] & (1<<ev)) != 0 )
1342
                    cyg_instrument_enable( cl<<8, ev );
1343
            }
1344
        }
1345
    }
1346
    cyg_scheduler_unlock();
1347
#endif
1348
 
1349
    return true;
1350
}
1351
 
1352
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_instrument_entry,
1353
                       "/monitor/instrument.htm*",
1354
                       cyg_monitor_instrument,
1355
                       NULL );
1356
 
1357
#endif
1358
 
1359
/* ================================================================= */
1360
/* eCos Logo
1361
 *
1362
 * Define the logo as a byte array, and then define the data structure
1363
 * and table entry to allow it to be fetched by the client.
1364
 */
1365
 
1366
static cyg_uint8 ecos_logo_gif[] = {
1367
    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x6f, 0x00, 0x23, 0x00, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00,
1368
    0xff, 0xff, 0xff, 0xea, 0x19, 0x00, 0xcc, 0x00, 0x00, 0xfd, 0xfd, 0xfd, 0x83, 0x00, 0x00, 0xf6,
1369
    0xf6, 0xf6, 0x2f, 0x2f, 0x2f, 0xef, 0xef, 0xef, 0x19, 0x00, 0x19, 0x45, 0x45, 0x45, 0xbb, 0xbb,
1370
    0xbb, 0xe2, 0x3e, 0x3e, 0xe8, 0xbb, 0xd3, 0x3e, 0x3e, 0x3e, 0xfb, 0xfb, 0xfb, 0xbe, 0xbe, 0xbe,
1371
    0xf1, 0xed, 0xed, 0xe5, 0x7b, 0x8e, 0xe5, 0x6b, 0x7b, 0xcc, 0xcc, 0xcc, 0x98, 0x95, 0x98, 0xc6,
1372
    0xc3, 0xc6, 0x19, 0x19, 0x19, 0xf1, 0xf1, 0xf1, 0x98, 0x98, 0x98, 0xd6, 0xd3, 0xd6, 0x83, 0x83,
1373
    0x83, 0xde, 0xde, 0xde, 0xe5, 0x25, 0x25, 0x73, 0x6f, 0x73, 0xea, 0xea, 0xea, 0xe5, 0x8e, 0xa2,
1374
    0xe8, 0xe8, 0xe8, 0x7f, 0x7b, 0x7f, 0xe2, 0x56, 0x66, 0x8b, 0x8b, 0x8b, 0x19, 0x19, 0x00, 0xf8,
1375
    0xf8, 0xf8, 0x73, 0x73, 0x73, 0xd3, 0xd1, 0xd1, 0x9c, 0x9c, 0x9c, 0x50, 0x50, 0x50, 0xef, 0xce,
1376
    0xea, 0x92, 0x8e, 0x92, 0x6f, 0x6f, 0x6f, 0xe2, 0x2f, 0x2f, 0x61, 0x61, 0x61, 0xe5, 0xe5, 0xe5,
1377
    0xe8, 0x9f, 0xb8, 0x37, 0x2f, 0x37, 0x66, 0x66, 0x66, 0xe2, 0x4b, 0x50, 0x56, 0x50, 0x56, 0xa9,
1378
    0xa5, 0xa9, 0xce, 0xce, 0xce, 0x56, 0x50, 0x50, 0xd9, 0xd9, 0xd9, 0x77, 0x73, 0x77, 0x25, 0x25,
1379
    0x2f, 0x6b, 0x6b, 0x6b, 0x9f, 0x9f, 0x9f, 0x87, 0x83, 0x87, 0x3e, 0x37, 0x37, 0xf4, 0xf4, 0xf4,
1380
    0x25, 0x25, 0x25, 0xc1, 0xc1, 0xc1, 0x83, 0x7f, 0x83, 0xe5, 0xe2, 0xe2, 0x4b, 0x45, 0x4b, 0xd1,
1381
    0xce, 0xd1, 0xaf, 0xac, 0xaf, 0xcc, 0xc9, 0xcc, 0x5b, 0x56, 0x5b, 0xdb, 0xd9, 0xdb, 0x66, 0x61,
1382
    0x66, 0xe2, 0xe2, 0xe2, 0xb8, 0xb5, 0xb8, 0x2f, 0x25, 0x2f, 0xc3, 0xc1, 0xc3, 0xe0, 0xde, 0xe0,
1383
    0xd3, 0xd3, 0xd3, 0xde, 0xdb, 0xde, 0xac, 0xac, 0xac, 0xce, 0xcc, 0xce, 0x77, 0x6f, 0x73, 0x4b,
1384
    0x45, 0x45, 0xc9, 0xc6, 0xc9, 0x45, 0x3e, 0x45, 0x61, 0x5b, 0x61, 0xb5, 0xb2, 0xb5, 0x3e, 0x00,
1385
    0x00, 0x8b, 0x87, 0x87, 0x95, 0x92, 0x95, 0xa2, 0x9f, 0xa2, 0xb8, 0xb8, 0xb8, 0x7b, 0x77, 0x7b,
1386
    0x9c, 0x98, 0x9c, 0x50, 0x4b, 0x50, 0x6f, 0x6b, 0x6f, 0x6b, 0x66, 0x6b, 0xac, 0xa9, 0xac, 0x8e,
1387
    0x8b, 0x8e, 0x8e, 0x00, 0x00, 0xdb, 0xdb, 0xdb, 0xed, 0xed, 0xed, 0x50, 0x4b, 0x4b, 0x3e, 0x37,
1388
    0x3e, 0x95, 0x95, 0x95, 0xa5, 0xa2, 0xa5, 0x9f, 0x9c, 0x9f, 0xc1, 0xbe, 0xbe, 0x2f, 0x25, 0x25,
1389
    0xd3, 0xd1, 0xd3, 0xf4, 0xf1, 0xf4, 0xc6, 0xc6, 0xc6, 0x8e, 0x8e, 0x8e, 0x25, 0x19, 0x19, 0x66,
1390
    0x61, 0x61, 0xb2, 0xaf, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1391
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1392
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1393
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1394
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1395
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1396
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1397
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1398
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1399
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1400
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1401
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1402
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1403
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1404
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1405
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1406
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1407
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1408
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1409
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1410
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1411
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1412
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1413
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1414
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1415
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
1416
    0x00, 0x00, 0x6f, 0x00, 0x23, 0x00, 0x40, 0x08, 0xff, 0x00, 0x03, 0x08, 0x1c, 0x28, 0x10, 0x41,
1417
    0x8a, 0x17, 0x0e, 0x1c, 0x00, 0x58, 0xc8, 0xb0, 0xa1, 0xc3, 0x87, 0x10, 0x21, 0x12, 0x14, 0x28,
1418
    0xa0, 0xa2, 0xc5, 0x8b, 0x18, 0x33, 0x6a, 0xdc, 0xb8, 0x91, 0x01, 0x83, 0x11, 0x31, 0x26, 0x12,
1419
    0x44, 0x10, 0x91, 0xe1, 0x09, 0x91, 0x28, 0x03, 0x4c, 0xb9, 0x50, 0x72, 0xa1, 0x0a, 0x04, 0x29,
1420
    0x09, 0x72, 0x6c, 0x10, 0x73, 0xe2, 0x88, 0x8d, 0x2e, 0x0c, 0xd4, 0x0c, 0x70, 0x73, 0x63, 0x80,
1421
    0x88, 0x10, 0x76, 0x0a, 0x6d, 0x18, 0x94, 0x60, 0x03, 0x8e, 0x1a, 0x27, 0x4a, 0x40, 0x5a, 0x51,
1422
    0xa9, 0xc5, 0x0e, 0x3b, 0x0d, 0x30, 0x40, 0xca, 0x40, 0x45, 0xc9, 0x14, 0x42, 0x45, 0x72, 0x60,
1423
    0xf9, 0xf0, 0x64, 0xd6, 0x00, 0x19, 0x3b, 0xe8, 0xfc, 0x3a, 0x70, 0xe9, 0x45, 0x10, 0x59, 0x0d,
1424
    0x70, 0x9c, 0x30, 0xf1, 0x44, 0xcb, 0xb7, 0x70, 0x4b, 0x8a, 0x64, 0x4a, 0xb7, 0xae, 0x5d, 0x01,
1425
    0x6c, 0x51, 0xbe, 0x88, 0xcb, 0xb7, 0xef, 0xc2, 0xb9, 0x77, 0x03, 0x0b, 0xbe, 0x98, 0x37, 0xc0,
1426
    0x81, 0x88, 0x58, 0x09, 0xde, 0xe0, 0xea, 0xf0, 0xc5, 0x44, 0x0e, 0x0f, 0x13, 0x13, 0x34, 0x30,
1427
    0x21, 0x23, 0xdb, 0x8c, 0x63, 0x07, 0x4a, 0xcd, 0x88, 0xd6, 0xa9, 0x45, 0x9a, 0x04, 0x69, 0x60,
1428
    0xec, 0xc0, 0x94, 0x41, 0x44, 0xaf, 0x03, 0x53, 0xf8, 0xdd, 0xd1, 0x10, 0xf5, 0xc0, 0xa9, 0x76,
1429
    0x41, 0x0f, 0x24, 0xcd, 0xb1, 0xf3, 0xc0, 0x9e, 0x1c, 0x25, 0x88, 0xac, 0xac, 0x91, 0x41, 0x00,
1430
    0xc8, 0x6f, 0x77, 0x48, 0x9e, 0x78, 0xc3, 0xaa, 0xdf, 0x03, 0x27, 0xa6, 0x40, 0x28, 0x2a, 0x13,
1431
    0xe9, 0x08, 0xd9, 0x93, 0x41, 0xd0, 0xe6, 0xd8, 0x41, 0x42, 0x83, 0x15, 0x02, 0x0d, 0x34, 0xe0,
1432
    0x8d, 0x34, 0x73, 0x6a, 0xc6, 0x7e, 0xc3, 0x3b, 0xff, 0x04, 0x3c, 0xb8, 0x3c, 0x5d, 0xdb, 0x03,
1433
    0xb7, 0xc2, 0x7d, 0x91, 0x02, 0xa6, 0xe2, 0x13, 0xe0, 0xf9, 0x22, 0x3f, 0xe1, 0x9a, 0x22, 0xd3,
1434
    0x09, 0xd0, 0x03, 0x18, 0x00, 0x01, 0x9b, 0x2e, 0x48, 0xec, 0x01, 0x34, 0x10, 0xc3, 0x04, 0xd3,
1435
    0x69, 0xa4, 0xd3, 0x5e, 0x11, 0x39, 0x46, 0x96, 0x40, 0x53, 0x44, 0xa4, 0x02, 0x59, 0x1a, 0xe5,
1436
    0x97, 0x95, 0x68, 0x17, 0xd1, 0x80, 0x92, 0x77, 0xfd, 0x69, 0x34, 0x81, 0x83, 0x6d, 0x25, 0xe4,
1437
    0xe1, 0x87, 0x0e, 0x3c, 0x48, 0x90, 0x6a, 0x0c, 0x89, 0x48, 0x10, 0x77, 0x74, 0x85, 0x44, 0x10,
1438
    0x6e, 0x11, 0x4e, 0xd4, 0x9f, 0x84, 0x2b, 0x10, 0x68, 0x97, 0x69, 0x10, 0x31, 0x27, 0xd0, 0x72,
1439
    0x38, 0xe6, 0xa8, 0x63, 0x8e, 0x44, 0x4d, 0x74, 0xd4, 0x5d, 0x13, 0xa1, 0xe8, 0x13, 0x41, 0x31,
1440
    0x60, 0xe4, 0x02, 0x7a, 0x22, 0xa9, 0xd5, 0xd1, 0x61, 0x35, 0x4e, 0x84, 0x80, 0x42, 0x0e, 0x5d,
1441
    0x70, 0x83, 0x48, 0xac, 0xf5, 0xe8, 0xa3, 0x46, 0x2e, 0xac, 0x30, 0x9a, 0x48, 0x45, 0x66, 0xc4,
1442
    0x80, 0x77, 0x01, 0x74, 0x69, 0x91, 0x75, 0x05, 0x0a, 0x80, 0xa4, 0x59, 0x5e, 0x92, 0x54, 0x92,
1443
    0x94, 0x5f, 0x3d, 0xf9, 0x16, 0x09, 0x59, 0x6d, 0x44, 0x03, 0x98, 0x31, 0xfd, 0x48, 0x58, 0x56,
1444
    0x20, 0x20, 0x45, 0x90, 0x71, 0xe2, 0xf5, 0x39, 0xde, 0x44, 0xe6, 0x05, 0xea, 0xdf, 0x4e, 0x1c,
1445
    0x90, 0xe0, 0x40, 0x95, 0x7e, 0xf2, 0x45, 0x9e, 0xa0, 0xe6, 0x75, 0xc0, 0x80, 0x04, 0x00, 0x0a,
1446
    0x85, 0x00, 0x82, 0x89, 0x86, 0xb7, 0x28, 0xa3, 0x82, 0x4e, 0x40, 0x27, 0x41, 0x94, 0x56, 0x2a,
1447
    0xde, 0xa5, 0x98, 0x32, 0x5a, 0x58, 0x6a, 0x7d, 0xed, 0x90, 0x10, 0x93, 0x9e, 0x02, 0x00, 0x2a,
1448
    0x47, 0x2e, 0x78, 0x14, 0x2a, 0x53, 0xb6, 0x75, 0xff, 0x0a, 0x91, 0x03, 0x53, 0xc6, 0x84, 0x00,
1449
    0x09, 0x7c, 0x5d, 0x70, 0x82, 0x7b, 0x29, 0x21, 0x25, 0xc1, 0xa6, 0x03, 0x35, 0x90, 0x61, 0x46,
1450
    0x2e, 0x48, 0x18, 0xec, 0xb0, 0x16, 0xb1, 0x45, 0x62, 0x44, 0x70, 0x92, 0xb5, 0x58, 0x49, 0x0a,
1451
    0x0a, 0xb5, 0x91, 0xb1, 0x31, 0xa1, 0x79, 0x11, 0xb5, 0x03, 0x69, 0xc9, 0x51, 0x0c, 0x50, 0x3e,
1452
    0x74, 0x01, 0xaf, 0x05, 0x9d, 0x80, 0xaa, 0x0a, 0x36, 0x0a, 0x24, 0x2b, 0x00, 0xdf, 0xa2, 0xb4,
1453
    0x82, 0x04, 0x13, 0x4c, 0x00, 0x02, 0x80, 0x96, 0xa1, 0xb4, 0x5d, 0xbb, 0x20, 0xd0, 0xa9, 0xe4,
1454
    0x98, 0x3e, 0xd2, 0x46, 0x43, 0x03, 0x76, 0x76, 0x24, 0x17, 0x41, 0xea, 0x31, 0x3b, 0x11, 0x9f,
1455
    0xe8, 0xa2, 0xe4, 0xc2, 0x46, 0x2c, 0x0a, 0x30, 0xc2, 0x44, 0x06, 0x1c, 0xac, 0x21, 0xc3, 0xd7,
1456
    0x4e, 0x24, 0xe6, 0x8c, 0x02, 0x2f, 0xe8, 0x64, 0x43, 0xcd, 0x36, 0x67, 0xd7, 0x44, 0xda, 0x72,
1457
    0x64, 0x21, 0x41, 0x68, 0xea, 0x96, 0xd2, 0x76, 0x74, 0xd1, 0xf8, 0x50, 0xb9, 0x16, 0xff, 0xc4,
1458
    0x50, 0xb9, 0xfd, 0x32, 0xe5, 0x42, 0x90, 0x74, 0x5d, 0x69, 0xd1, 0xc2, 0x3b, 0x21, 0x6b, 0x91,
1459
    0xc9, 0x0e, 0x65, 0x2c, 0x10, 0xaa, 0xe2, 0x4d, 0xc1, 0x71, 0x60, 0x32, 0xb3, 0xea, 0x59, 0x46,
1460
    0x20, 0x6d, 0x6a, 0xb3, 0x00, 0x38, 0x37, 0xb4, 0x83, 0x48, 0xdd, 0x46, 0x09, 0x62, 0x42, 0x4a,
1461
    0x8b, 0xd4, 0x31, 0xb1, 0x18, 0x89, 0x1c, 0x2c, 0x47, 0xbe, 0x01, 0x7a, 0xde, 0xd0, 0x18, 0x31,
1462
    0xd0, 0x74, 0x43, 0x0e, 0xa0, 0x34, 0x85, 0x0a, 0x87, 0x39, 0x40, 0x02, 0xb8, 0x02, 0xe1, 0xea,
1463
    0x50, 0xd8, 0x49, 0x4a, 0x00, 0x1b, 0x0d, 0x9d, 0x71, 0x96, 0xe4, 0x04, 0x53, 0x75, 0x00, 0x37,
1464
    0x4a, 0x05, 0x42, 0xa5, 0x9f, 0xdb, 0x15, 0x8d, 0x61, 0x2a, 0xd0, 0xd1, 0x0c, 0x2c, 0x0b, 0x51,
1465
    0xad, 0x6d, 0xf2, 0xec, 0xd0, 0x70, 0x35, 0x61, 0x69, 0x71, 0xcb, 0x7a, 0x0b, 0x65, 0x2d, 0x46,
1466
    0x21, 0x11, 0x0c, 0x91, 0xce, 0x29, 0x41, 0x80, 0x68, 0x4b, 0x0e, 0xa0, 0xac, 0x35, 0x96, 0xd8,
1467
    0x96, 0xd5, 0x51, 0xe7, 0x8f, 0x63, 0x44, 0x73, 0x00, 0x6e, 0xc5, 0xa5, 0x02, 0x09, 0xa8, 0x93,
1468
    0xf0, 0xc2, 0xe5, 0x7e, 0xae, 0x1a, 0xd6, 0x08, 0x12, 0xc4, 0x2e, 0x01, 0x85, 0xaf, 0x66, 0x64,
1469
    0x75, 0x41, 0x5f, 0xa7, 0xaa, 0xe8, 0xe6, 0xb5, 0x0b, 0x3a, 0x3a, 0x4a, 0x37, 0xe4, 0xae, 0xfb,
1470
    0xbf, 0x1a, 0xf7, 0x3e, 0x18, 0x0d, 0x91, 0x0e, 0x14, 0x10, 0x00, 0x3b
1471
};
1472
 
1473
CYG_HTTPD_DATA( cyg_monitor_ecos_logo_data,
1474
                "image/gif",
1475
                sizeof(ecos_logo_gif), ecos_logo_gif );
1476
 
1477
CYG_HTTPD_TABLE_ENTRY( cyg_monitor_ecos_logo,
1478
                       "/monitor/ecos.gif",
1479
                       cyg_httpd_send_data,
1480
                       &cyg_monitor_ecos_logo_data );
1481
 
1482
/*------------------------------------------------------------------ */
1483
/* end of monitor.c                                                  */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.