| /demos/trunk/tracer/dfixed/dfixed.c |
|---|
| 0,0 → 1,133 |
| /* |
| * Project: HARTIK (HA-rd R-eal TI-me K-ernel) |
| * |
| * Coordinators: Giorgio Buttazzo <giorgio@sssup.it> |
| * Gerardo Lamastra <gerardo@sssup.it> |
| * |
| * Authors : Massimiliano Giorgi <massy@hartik.sssup.it> |
| * (see authors.txt for full list of hartik's authors) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://hartik.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: dfixed.c,v 1.2 2003-12-17 14:15:45 giacomo Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.2 $ |
| * Last update: $Date: 2003-12-17 14:15:45 $ |
| */ |
| /* |
| * Example of tracer initialization. |
| */ |
| #include <ll/i386/cons.h> |
| #include <kernel/func.h> |
| #include <tracer.h> |
| #include <fs/bdevinit.h> |
| #include <fs/fsinit.h> |
| #include <fs/bdev.h> |
| #include <drivers/keyb.h> |
| #include <trace.h> |
| #include <queues.h> |
| #include <sys/mount.h> |
| #include <stddef.h> |
| void mytracer_prologue(void) |
| { |
| int myqueue; |
| TRC_PARMS p; |
| TRC_FIXED_PARMS f; |
| trc_default_parms(p); |
| trc_def_path(p,""); |
| trc_fixed_default_parms(f); |
| trc_fixed_def_filename(f,"fixed"); |
| /* Tracer Initialization */ |
| /* the first functions to call... parameters can be passed */ |
| TRC_init_phase1(&p); |
| /* all the tracer queue types must be registered */ |
| trc_register_dosfs_fixed_queue(); |
| /* then, we create all the queues we need */ |
| myqueue = trc_create_queue(TRC_DOSFS_FIXED_QUEUE,&f); |
| /* Then, we say that events must be sent to a particular queue */ |
| trc_trace_class(TRC_CLASS_SYSTEM); |
| trc_assign_class_to_queue(TRC_CLASS_SYSTEM, myqueue); |
| } |
| void mytracer_epilogue(void) |
| { |
| TRC_init_phase2(); |
| } |
| void ctrlc_exit(KEY_EVT *k) |
| { |
| sys_end(); |
| } |
| void *mytask(void *arg) |
| { |
| int i; |
| for(i=0; i<10; i++) { |
| cprintf("%d ", i); |
| task_endcycle(); |
| } |
| return 0; |
| } |
| int main(int argc,char *argv[]) |
| { |
| SOFT_TASK_MODEL mp; |
| PID pid; |
| soft_task_default_model(mp); |
| soft_task_def_met(mp, 10000); |
| soft_task_def_period(mp,50000); |
| soft_task_def_usemath(mp); |
| cprintf("\nHello, world!\n"); |
| pid = task_create("mytask", mytask, &mp, NULL); |
| if (pid != NIL) task_activate(pid); |
| return 0; |
| } |
| /demos/trunk/tracer/dfixed/makefile |
|---|
| 0,0 → 1,21 |
| # |
| # |
| # |
| ifndef BASE |
| BASE=../../.. |
| endif |
| include $(BASE)/config/config.mk |
| PROGS= dfixed |
| include $(BASE)/config/example.mk |
| dfixed: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=dfixed INIT= OTHEROBJS=initfile.o SHARKOPT=__OLDCHAR__ |
| /demos/trunk/tracer/dfixed/initfile.c |
|---|
| 0,0 → 1,115 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: initfile.c,v 1.1 2002-10-21 09:12:35 pj Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.1 $ |
| * Last update: $Date: 2002-10-21 09:12:35 $ |
| */ |
| #include "kernel/kern.h" |
| #include "modules/edf.h" |
| #include "modules/rr.h" |
| #include "modules/cbs.h" |
| #include "modules/dummy.h" |
| #include "modules/sem.h" |
| #include "modules/hartport.h" |
| #include "modules/cabs.h" |
| #include "modules/pi.h" |
| #include "modules/pc.h" |
| #include "modules/srp.h" |
| #include "modules/npp.h" |
| #include "modules/nop.h" |
| #include "modules/nopm.h" |
| #include "drivers/keyb.h" |
| /*+ sysyem tick in us +*/ |
| #define TICK 1000 |
| /*+ RR tick in us +*/ |
| #define RRTICK 10000 |
| void mytracer_prologue(void); |
| void mytracer_epilogue(void); |
| TIME __kernel_register_levels__(void *arg) |
| { |
| struct multiboot_info *mb = (struct multiboot_info *)arg; |
| mytracer_prologue(); |
| EDF_register_level(EDF_ENABLE_ALL); |
| RR_register_level(RRTICK, RR_MAIN_YES, mb); |
| CBS_register_level(CBS_ENABLE_ALL, 0); |
| dummy_register_level(); |
| SEM_register_module(); |
| CABS_register_module(); |
| PI_register_module(); |
| PC_register_module(); |
| NPP_register_module(); |
| SRP_register_module(); |
| NOP_register_module(); |
| NOPM_register_module(); |
| return TICK; |
| } |
| TASK __init__(void *arg) |
| { |
| struct multiboot_info *mb = (struct multiboot_info *)arg; |
| KEYB_PARMS keyb = BASE_KEYB; |
| extern void ctrlc_exit(KEY_EVT *k); |
| HARTPORT_init(); |
| keyb_def_ctrlC(keyb, ctrlc_exit); |
| KEYB_init(&keyb); |
| mytracer_epilogue(); |
| __call_main__(mb); |
| return (void *)0; |
| } |
| /demos/trunk/tracer/dfixed/readme |
|---|
| 0,0 → 1,8 |
| This is a simple test that uses the tracer. |
| The example simply creates a soft task that does 10 instances and then dies. |
| It uses a DOSFS Fixed queue to write the output on a file. |
| Enjoy, |
| PJ |
| /demos/trunk/tracer/small/hello.c |
|---|
| 0,0 → 1,209 |
| /* |
| * Project: HARTIK (HA-rd R-eal TI-me K-ernel) |
| * |
| * Coordinators: Giorgio Buttazzo <giorgio@sssup.it> |
| * Gerardo Lamastra <gerardo@sssup.it> |
| * |
| * Authors : Massimiliano Giorgi <massy@hartik.sssup.it> |
| * (see authors.txt for full list of hartik's authors) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://hartik.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: hello.c,v 1.2 2003-12-17 14:15:45 giacomo Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.2 $ |
| * Last update: $Date: 2003-12-17 14:15:45 $ |
| */ |
| /* |
| * Example of tracer initialization. |
| */ |
| #include <ll/i386/cons.h> |
| #include <kernel/func.h> |
| #include <tracer.h> |
| #include <fs/bdevinit.h> |
| #include <fs/fsinit.h> |
| #include <fs/bdev.h> |
| #include <drivers/keyb.h> |
| #include <trace.h> |
| #include <queues.h> |
| #include <sys/mount.h> |
| #include <stddef.h> |
| /* |
| this example use initfs.c to initialize the system; this file define |
| the following two function. |
| __kernel_register_levels__(), must initialize all kernel modules, |
| it has this structure: |
| { |
| __register_sub_init_prologue(); |
| ... modules initialization.... |
| __register_sub_init(); |
| } |
| __init__(void *arg) is called when the first task is created |
| and must call the main(): |
| { |
| ... drivers initialization .... |
| __bdev_sub_init(); |
| __fs_sub_init(); |
| call_main() |
| } |
| */ |
| /* |
| * This function is called before all other modules initialization because |
| * all modules that need the tracer must follow tracer initialization. |
| */ |
| int __register_sub_init_prologue(void) |
| { |
| /* the first functions to call... parameters can be passed */ |
| TRC_init_phase1(NULL); |
| /* all the tracer queues must be registrated (in this case only */ |
| /* a dummy queue is initialized) */ |
| trc_register_dummy_queue(); |
| /* the queues must be created (only one in this example) */ |
| trc_create_queue(TRC_DUMMY_QUEUE,NULL); |
| /* events can be dispatch to a queue (nothing in this case) */ |
| return 0; |
| } |
| /* |
| * This function is called after all other modules initialization |
| * functions... notjing to do. |
| */ |
| int __register_sub_init(void) |
| { |
| return 0; |
| } |
| __dev_t root_device; |
| __dev_t temp_device; |
| /* |
| * Now the system is running... we have to initialize the block device |
| * drivers |
| */ |
| int __bdev_sub_init(void) |
| { |
| BDEV_PARMS bdev=BASE_BDEV; |
| /* This to initialize the block device drivers... a NULL can be passed */ |
| /* to the bdev_init() functions */ |
| bdev_def_showinfo(bdev,FALSE); |
| bdev_init(&bdev); |
| /* The following phase ca be made in several way: we must decide the */ |
| /* device that we want mount as root... we use the bdev_find_byname() */ |
| /* functions to find a specific device */ |
| root_device=bdev_find_byname("ide/hda1"); |
| if (root_device<0) { |
| cprintf("can't find root device to mount on /!!!\n"); |
| sys_end(); |
| return -1; |
| } |
| /* Well, we want a device to mount into /TEMP */ |
| temp_device=bdev_find_byname("ide/hdb3"); |
| if (temp_device<0) { |
| cprintf("can't find a filesystem to mount on /TEMP!!!\n"); |
| sys_end(); |
| return -1; |
| } |
| return 0; |
| } |
| /* |
| * This is the real filesystem initialization! |
| */ |
| int __fs_sub_init(void) |
| { |
| FILESYSTEM_PARMS fs=BASE_FILESYSTEM; |
| extern int libc_initialize(void); |
| int res; |
| struct mount_opts opts; |
| /* We set the root device and call the filesystem_init() function */ |
| filesystem_def_rootdevice(fs,root_device); |
| filesystem_def_fs(fs,FS_MSDOS); |
| filesystem_def_showinfo(fs,FALSE); |
| filesystem_init(&fs); |
| /* We must initialize the libC if we use it */ |
| libc_initialize(); |
| /* We have choose to mount the second partiotion into the /TEMP */ |
| /* directory with read/write privilegies (this step is not required) */ |
| if (temp_device>=0) { |
| memset(&opts,0,sizeof(struct mount_opts)); |
| opts.flags=MOUNT_FLAG_RW; |
| res=mount(temp_device,FS_MSDOS,"/TEMP",&opts); |
| if (res!=0) { |
| cprintf("can't mount XXX on /TEMP (errno: %i)\n",errno); |
| } |
| } |
| /* NOW we call the tracer initialization phase 2!!! */ |
| /* It must FOLLOW the filesystem initialization... (this function */ |
| /* can be called after the call to filesystem_init() functions but */ |
| /* we do it here because we want be able to write into the /TEMP */ |
| /* directory! */ |
| TRC_init_phase2(); |
| return 0; |
| } |
| void ctrlc_exit(KEY_EVT *k) |
| { |
| sys_end(); |
| } |
| int main(int argc,char *argv[]) |
| { |
| cprintf("\nHello, world!\n"); |
| return 0; |
| } |
| /demos/trunk/tracer/small/common.c |
|---|
| 0,0 → 1,133 |
| #include <kernel/func.h> |
| #include <tracer.h> |
| #include <fs/bdevinit.h> |
| #include <fs/fsinit.h> |
| #include <fs/bdev.h> |
| #include <drivers/keyb.h> |
| #include <trace.h> |
| #include <queues.h> |
| #include <sys/mount.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <errno.h> |
| int __register_sub_init(void) |
| { |
| return 0; |
| } |
| /* -- */ |
| __dev_t root_device; |
| __dev_t temp_device; |
| int choose_root_callback(__dev_t dev,__uint8_t fs) |
| { |
| if (fs==FS_MSDOS) return dev; |
| return -1; |
| } |
| int choose_temp_callback(__dev_t dev,__uint8_t fs) |
| { |
| static int flag=0; |
| if (fs==FS_MSDOS) { |
| if (flag) return dev; |
| flag=1; |
| } |
| return -1; |
| } |
| /* -- */ |
| extern int bdev_scan_devices(int(*callback)(__dev_t,__uint8_t)); |
| int __bdev_sub_init(void) |
| { |
| BDEV_PARMS bdev=BASE_BDEV; |
| bdev_def_showinfo(bdev,FALSE); |
| bdev_init(&bdev); |
| root_device=bdev_scan_devices(choose_root_callback); |
| if (root_device<0) { |
| cprintf("can't find root device to mount on /!!!\n"); |
| sys_end(); |
| return -1; |
| } |
| temp_device=bdev_scan_devices(choose_temp_callback); |
| if (temp_device<0) { |
| cprintf("can't find a filesystem to mount on /TEMP!!!\n"); |
| } |
| return 0; |
| } |
| /* -- */ |
| extern int libc_initialize(void); |
| int __fs_sub_init(void) |
| { |
| FILESYSTEM_PARMS fs=BASE_FILESYSTEM; |
| struct mount_opts opts; |
| int res; |
| filesystem_def_rootdevice(fs,root_device); |
| filesystem_def_fs(fs,FS_MSDOS); |
| filesystem_def_showinfo(fs,FALSE); |
| //filesystem_init_prologue(); |
| filesystem_init(&fs); |
| libc_initialize(); |
| if (temp_device>=0) { |
| memset(&opts,0,sizeof(struct mount_opts)); |
| opts.flags=MOUNT_FLAG_RW; |
| res=mount(temp_device,FS_MSDOS,"/TEMP",&opts); |
| if (res!=0) { |
| cprintf("can't mount XXX on /TEMP (errno: %i)\n",errno); |
| } |
| } |
| TRC_init_phase2(); |
| return 0; |
| } |
| /* -- */ |
| void ctrlc_exit(KEY_EVT *k) |
| { |
| extern void dump_sem_table(void); |
| extern void dump_nop_table(void); |
| //dump_sem_table(); |
| //dump_nop_table(); |
| sys_end(); |
| } |
| /* -- */ |
| void showmessage(char *s) |
| { |
| cputs(s); |
| cprintf("Press [x] to begin..."); |
| while (keyb_getchar()!='x'); |
| cprintf("\n"); |
| } |
| void waitend(void) |
| { |
| int c; |
| cprintf("Press [x] to exit..."); |
| while ((c=keyb_getchar())!='x'); |
| cprintf("\n"); |
| } |
| /demos/trunk/tracer/small/simple.c |
|---|
| 0,0 → 1,132 |
| /* |
| * Project: HARTIK (HA-rd R-eal TI-me K-ernel) |
| * |
| * Coordinators: Giorgio Buttazzo <giorgio@sssup.it> |
| * Gerardo Lamastra <gerardo@sssup.it> |
| * |
| * Authors : Massimiliano Giorgi <massy@hartik.sssup.it> |
| * (see authors.txt for full list of hartik's authors) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://hartik.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: simple.c,v 1.2 2003-12-17 14:15:45 giacomo Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.2 $ |
| * Last update: $Date: 2003-12-17 14:15:45 $ |
| */ |
| /* |
| * Example of simple tracer initialization. |
| */ |
| #include <ll/i386/cons.h> |
| #include <kernel/func.h> |
| #include <trace.h> |
| #include <fs/bdevinit.h> |
| #include <fs/fsinit.h> |
| #include <fs/bdev.h> |
| #include <drivers/keyb.h> |
| #include <trace.h> |
| #include <sys/mount.h> |
| #include <stddef.h> |
| #define ROOTDEVICE "ide/hda2" |
| int __register_sub_init_prologue(void) |
| { |
| int res; |
| /* tracer initialization phase 1 */ |
| res=TRC_init_phase1_standard(); |
| if (res!=0) { |
| cprintf("tracer initialization error (%i)!!!\n",res); |
| sys_end(); |
| return -1; |
| } |
| return 0; |
| } |
| int __register_sub_init(void) |
| { |
| return 0; |
| } |
| __dev_t root_device; |
| int __bdev_sub_init(void) |
| { |
| /* block device initialization */ |
| bdev_init(NULL); |
| /* choose root device */ |
| root_device=bdev_find_byname(ROOTDEVICE); |
| if (root_device<0) { |
| cprintf("can't find root device to mount on /!!!\n"); |
| sys_end(); |
| return -1; |
| } |
| return 0; |
| } |
| int __fs_sub_init(void) |
| { |
| FILESYSTEM_PARMS fs=BASE_FILESYSTEM; |
| extern int libc_initialize(void); |
| /* filesystems initialization */ |
| filesystem_def_rootdevice(fs,root_device); |
| filesystem_def_fs(fs,FS_MSDOS); |
| filesystem_def_showinfo(fs,FALSE); |
| filesystem_init(&fs); |
| /* libC initialization */ |
| libc_initialize(); |
| /* tracer initialization phase 2 */ |
| TRC_init_phase2_standard(); |
| return 0; |
| } |
| void ctrlc_exit(KEY_EVT *k) |
| { |
| sys_end(); |
| } |
| int main(int argc,char *argv[]) |
| { |
| cprintf("\nSimple hello world (with tracer)!\n\n"); |
| return 0; |
| } |
| /demos/trunk/tracer/small/makefile |
|---|
| 0,0 → 1,29 |
| # |
| # |
| # |
| ifndef BASE |
| BASE=../../.. |
| endif |
| include $(BASE)/config/config.mk |
| PROGS= simple hello hello1 hello2 test0 treef1 treec1 treec2 |
| include $(BASE)/config/example.mk |
| simple: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=simple OTHEROBJS=initfs.o SHARKOPT=__OLDCHAR__ |
| hello: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=hello OTHEROBJS=initfs.o SHARKOPT=__OLDCHAR__ |
| hello1: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=hello1 OTHEROBJS="initfs.o common.o" SHARKOPT=__OLDCHAR__ |
| hello2: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=hello2 OTHEROBJS="initfs.o common.o" SHARKOPT=__OLDCHAR__ |
| test0: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=test0 OTHEROBJS="initfs.o common.o" SHARKOPT=__OLDCHAR__ |
| treef1: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=treef1 OTHEROBJS="initfs.o common.o" SHARKOPT=__OLDCHAR__ |
| treec1: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=treec1 OTHEROBJS="initfs.o common.o" SHARKOPT=__OLDCHAR__ |
| treec2: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=treec2 OTHEROBJS="initfs.o common.o" SHARKOPT=__OLDCHAR__ |
| /demos/trunk/tracer/small/treec1.c |
|---|
| 0,0 → 1,220 |
| /* |
| * |
| * |
| * |
| */ |
| #include <kernel/func.h> |
| #include <kernel/model.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/mount.h> |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <semaphore.h> |
| #include <stdio.h> |
| #include <time.h> |
| #include "common.h" |
| #include <trace/trace.h> |
| #include <trace/queues.h> |
| int noscroll=0; |
| SEM console; |
| #define MPROC ((50<(MAX_PROC-10))?50:MAX_PROC-10) |
| TASK viewdir(void *prof); |
| sem_t actmutex,actsync; |
| char *globpathname; |
| PID globpid; |
| int counter=0,actcounter=0; |
| void activate_task(int prof, char *pathname) |
| { |
| char tname[32]; |
| NRT_TASK_MODEL m; |
| PID pid; |
| REPEAT: |
| sem_wait(&actmutex); |
| if (actcounter>=MPROC) { |
| struct timespec delay; |
| delay.tv_sec = 0; |
| delay.tv_nsec = 10000000; |
| sem_signal(&actmutex); |
| nanosleep(&delay, NULL); |
| goto REPEAT; |
| } |
| globpathname=pathname; |
| counter++; |
| sprintf(tname,"tsk%i",counter); |
| nrt_task_default_model(m); |
| nrt_task_def_arg(m,(void*)counter); |
| globpid=pid=task_create(tname,viewdir,&m,NULL); |
| if (pid==-1) { |
| sem_wait(&console); |
| cprintf("can't create '%s'\n",tname); |
| perror("can't create task"); |
| sem_signal(&console); |
| sys_end(); |
| return; |
| } |
| task_activate(pid); |
| sem_wait(&actsync); |
| actcounter++; |
| sem_signal(&actmutex); |
| } |
| /* |
| * |
| */ |
| int filecounter=0; |
| TASK viewdir(void *pointer) |
| { |
| struct dirent *den; |
| struct stat st; |
| char *str; |
| DIR *d; |
| int res; |
| int x; |
| char pathname[1024]; |
| PID mypid; |
| int prof=(int)pointer; |
| strcpy(pathname,globpathname); |
| mypid=globpid; |
| sem_signal(&actsync); |
| str=pathname+(x=strlen(pathname)); |
| d=opendir(pathname); |
| if (d==NULL) { |
| sem_wait(&console); |
| cprintf("%03i ERR: can't open dir %s\n",prof,pathname); |
| cprintf("errno: %i '%s'\n",errno,strerror(errno)); |
| sem_signal(&console); |
| sys_end(); |
| l1_exit(0); |
| goto END; |
| } |
| while ((den=readdir(d))!=NULL) { |
| if (x==1&&*pathname=='/') |
| strcat(pathname,den->d_name); |
| else |
| strcat(strcat(pathname,"/"),den->d_name); |
| sem_wait(&console); |
| if (noscroll) { |
| place(0,10); |
| cprintf(" "); |
| place(0,10); |
| } |
| cprintf("t%03i %s\n",prof,pathname); |
| filecounter++; |
| sem_signal(&console); |
| if (!strcmp(den->d_name,".")) goto SKIP; |
| if (!strcmp(den->d_name,"..")) goto SKIP; |
| res=stat(pathname,&st); |
| if (res!=0) { |
| sem_wait(&console); |
| cprintf("t%03i can't stat %s\n",prof,pathname); |
| cprintf("errno: %i '%s'\n",errno,strerror(errno)); |
| sem_signal(&console); |
| sys_end(); |
| l1_exit(0); |
| closedir(d); |
| goto END; |
| } else { |
| if (S_ISDIR(st.st_mode)) { |
| sem_wait(&console); |
| sem_signal(&console); |
| activate_task(prof,pathname); |
| } |
| } |
| SKIP: |
| *str='\0'; |
| } |
| closedir(d); |
| END: |
| sem_wait(&actmutex); |
| actcounter--; |
| sem_signal(&actmutex); |
| return 0; |
| } |
| /* |
| * |
| */ |
| int __register_sub_init_prologue(void) |
| { |
| TRC_init_phase1(NULL); |
| trc_register_circular_queue(); |
| trc_create_queue(TRC_CIRCULAR_QUEUE,NULL); |
| return 0; |
| } |
| /* |
| * |
| */ |
| int main(int argc,char *argv[]) |
| { |
| // int res; |
| showmessage("This test show all filenames of a directory of an hardisk\n" |
| "recursively using a soft task for every directory.\n" |
| "The tracer with a circular queue is activated.\n"); |
| sem_init(&console,0,1); |
| sem_init(&actmutex,0,1); |
| sem_init(&actsync,0,0); |
| activate_task(-1,FROMDIR); |
| { |
| struct timespec delay; |
| delay.tv_sec = 0; |
| delay.tv_nsec = 500000000; |
| for(;;) { |
| sem_wait(&actmutex); |
| if (actcounter==0) break; |
| sem_signal(&actmutex); |
| nanosleep(&delay, NULL); |
| } |
| } |
| cprintf("\nfiles: %i\n",filecounter); |
| waitend(); |
| return 0; |
| } |
| /demos/trunk/tracer/small/treec2.c |
|---|
| 0,0 → 1,233 |
| /* |
| * |
| * |
| * |
| */ |
| #include <kernel/func.h> |
| #include <kernel/model.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/mount.h> |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <semaphore.h> |
| #include <stdio.h> |
| #include <time.h> |
| #include "common.h" |
| #include <trace/trace.h> |
| #include <trace/queues.h> |
| #define sem_signal sem_post |
| int noscroll=0; |
| SEM console; |
| #define MPROC ((50<(MAX_PROC-10))?50:MAX_PROC-10) |
| TASK viewdir(void *prof); |
| sem_t actmutex,actsync; |
| char *globpathname; |
| PID globpid; |
| int counter=0,actcounter=0; |
| void activate_task(int prof, char *pathname) |
| { |
| char tname[32]; |
| NRT_TASK_MODEL m; |
| PID pid; |
| REPEAT: |
| sem_wait(&actmutex); |
| if (actcounter>=MPROC) { |
| struct timespec delay; |
| delay.tv_sec = 0; |
| delay.tv_nsec = 10000000; |
| sem_signal(&actmutex); |
| nanosleep(&delay, NULL); |
| goto REPEAT; |
| } |
| globpathname=pathname; |
| counter++; |
| sprintf(tname,"tsk%i",counter); |
| nrt_task_default_model(m); |
| nrt_task_def_arg(m,(void*)counter); |
| globpid=pid=task_create(tname,viewdir,&m,NULL); |
| if (pid==-1) { |
| sem_wait(&console); |
| cprintf("can't create '%s'\n",tname); |
| perror("can't create task"); |
| sem_signal(&console); |
| sys_end(); |
| return; |
| } |
| task_activate(pid); |
| sem_wait(&actsync); |
| actcounter++; |
| sem_signal(&actmutex); |
| } |
| /* |
| * |
| */ |
| int filecounter=0; |
| TASK viewdir(void *pointer) |
| { |
| struct dirent *den; |
| struct stat st; |
| char *str; |
| DIR *d; |
| int res; |
| int x; |
| char pathname[1024]; |
| PID mypid; |
| int prof=(int)pointer; |
| strcpy(pathname,globpathname); |
| mypid=globpid; |
| sem_signal(&actsync); |
| str=pathname+(x=strlen(pathname)); |
| d=opendir(pathname); |
| if (d==NULL) { |
| sem_wait(&console); |
| cprintf("%03i ERR: can't open dir %s\n",prof,pathname); |
| cprintf("errno: %i '%s'\n",errno,strerror(errno)); |
| sem_signal(&console); |
| sys_end(); |
| l1_exit(0); |
| goto END; |
| } |
| while ((den=readdir(d))!=NULL) { |
| if (x==1&&*pathname=='/') |
| strcat(pathname,den->d_name); |
| else |
| strcat(strcat(pathname,"/"),den->d_name); |
| sem_wait(&console); |
| if (noscroll) { |
| place(0,10); |
| cprintf(" "); |
| place(0,10); |
| } |
| cprintf("t%03i %s\n",prof,pathname); |
| filecounter++; |
| sem_signal(&console); |
| if (!strcmp(den->d_name,".")) goto SKIP; |
| if (!strcmp(den->d_name,"..")) goto SKIP; |
| res=stat(pathname,&st); |
| if (res!=0) { |
| sem_wait(&console); |
| cprintf("t%03i can't stat %s\n",prof,pathname); |
| cprintf("errno: %i '%s'\n",errno,strerror(errno)); |
| sem_signal(&console); |
| sys_end(); |
| l1_exit(0); |
| closedir(d); |
| goto END; |
| } else { |
| if (S_ISDIR(st.st_mode)) { |
| sem_wait(&console); |
| sem_signal(&console); |
| activate_task(prof,pathname); |
| } |
| } |
| SKIP: |
| *str='\0'; |
| } |
| closedir(d); |
| END: |
| sem_wait(&actmutex); |
| actcounter--; |
| sem_signal(&actmutex); |
| return 0; |
| } |
| /* |
| * |
| */ |
| int __register_sub_init_prologue(void) |
| { |
| TRC_CIRCULAR_PARMS args; |
| int q; |
| TRC_init_phase1(NULL); |
| trc_register_circular_queue(); |
| trc_circular_default_parms(args); |
| trc_circular_def_onlinetask(args); |
| q=trc_create_queue(TRC_CIRCULAR_QUEUE,&args); |
| trc_assign_class_to_queue(TRC_CLASS_SYSTEM,q); |
| trc_trace_class(TRC_CLASS_SYSTEM); |
| return 0; |
| } |
| /* |
| * |
| */ |
| int main(int argc,char *argv[]) |
| { |
| // int res; |
| showmessage("This test show all filenames of a directory of an hardisk\n" |
| "recursively using a soft task for every directory.\n" |
| "The tracer with a circular queue is activated that write\n" |
| "on hardisk online (while the system is running)\n"); |
| sem_init(&console,0,1); |
| sem_init(&actmutex,0,1); |
| sem_init(&actsync,0,0); |
| activate_task(-1,FROMDIR); |
| //activate_task(-1,"/"); |
| { |
| struct timespec delay; |
| delay.tv_sec = 0; |
| delay.tv_nsec = 500000000; |
| for(;;) { |
| sem_wait(&actmutex); |
| if (actcounter==0) break; |
| sem_signal(&actmutex); |
| nanosleep(&delay, NULL); |
| } |
| } |
| cprintf("\nfiles: %i\n",filecounter); |
| waitend(); |
| return 0; |
| } |
| /demos/trunk/tracer/small/treef1.c |
|---|
| 0,0 → 1,224 |
| /* |
| * |
| * |
| * |
| */ |
| #include <kernel/func.h> |
| #include <kernel/model.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/mount.h> |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <semaphore.h> |
| #include <stdio.h> |
| #include <time.h> |
| #include "common.h" |
| #include <trace/trace.h> |
| #include <trace/queues.h> |
| #define sem_signal sem_post |
| int noscroll=0; |
| SEM console; |
| #define MPROC ((50<(MAX_PROC-10))?50:MAX_PROC-10) |
| TASK viewdir(void *prof); |
| sem_t actmutex,actsync; |
| char *globpathname; |
| PID globpid; |
| int counter=0,actcounter=0; |
| void activate_task(int prof, char *pathname) |
| { |
| char tname[32]; |
| NRT_TASK_MODEL m; |
| PID pid; |
| REPEAT: |
| sem_wait(&actmutex); |
| if (actcounter>=MPROC) { |
| struct timespec delay; |
| delay.tv_sec = 0; |
| delay.tv_nsec = 10000000; |
| sem_signal(&actmutex); |
| nanosleep(&delay, NULL); |
| goto REPEAT; |
| } |
| globpathname=pathname; |
| counter++; |
| sprintf(tname,"tsk%i",counter); |
| nrt_task_default_model(m); |
| nrt_task_def_arg(m,(void*)counter); |
| globpid=pid=task_create(tname,viewdir,&m,NULL); |
| if (pid==-1) { |
| sem_wait(&console); |
| cprintf("can't create '%s'\n",tname); |
| perror("can't create task"); |
| sem_signal(&console); |
| sys_end(); |
| return; |
| } |
| task_activate(pid); |
| sem_wait(&actsync); |
| actcounter++; |
| sem_signal(&actmutex); |
| } |
| /* |
| * |
| */ |
| int filecounter=0; |
| TASK viewdir(void *pointer) |
| { |
| struct dirent *den; |
| struct stat st; |
| char *str; |
| DIR *d; |
| int res; |
| int x; |
| char pathname[1024]; |
| PID mypid; |
| int prof=(int)pointer; |
| strcpy(pathname,globpathname); |
| mypid=globpid; |
| sem_signal(&actsync); |
| str=pathname+(x=strlen(pathname)); |
| d=opendir(pathname); |
| if (d==NULL) { |
| sem_wait(&console); |
| cprintf("%03i ERR: can't open dir %s\n",prof,pathname); |
| cprintf("errno: %i '%s'\n",errno,strerror(errno)); |
| sem_signal(&console); |
| sys_end(); |
| l1_exit(0); |
| goto END; |
| } |
| while ((den=readdir(d))!=NULL) { |
| if (x==1&&*pathname=='/') |
| strcat(pathname,den->d_name); |
| else |
| strcat(strcat(pathname,"/"),den->d_name); |
| sem_wait(&console); |
| if (noscroll) { |
| place(0,10); |
| cprintf(" "); |
| place(0,10); |
| } |
| cprintf("t%03i %s\n",prof,pathname); |
| filecounter++; |
| sem_signal(&console); |
| if (!strcmp(den->d_name,".")) goto SKIP; |
| if (!strcmp(den->d_name,"..")) goto SKIP; |
| res=stat(pathname,&st); |
| if (res!=0) { |
| sem_wait(&console); |
| cprintf("t%03i can't stat %s\n",prof,pathname); |
| cprintf("errno: %i '%s'\n",errno,strerror(errno)); |
| sem_signal(&console); |
| sys_end(); |
| l1_exit(0); |
| closedir(d); |
| goto END; |
| } else { |
| if (S_ISDIR(st.st_mode)) { |
| sem_wait(&console); |
| sem_signal(&console); |
| activate_task(prof,pathname); |
| } |
| } |
| SKIP: |
| *str='\0'; |
| } |
| closedir(d); |
| END: |
| sem_wait(&actmutex); |
| actcounter--; |
| sem_signal(&actmutex); |
| return 0; |
| } |
| /* |
| * |
| */ |
| int __register_sub_init_prologue(void) |
| { |
| int q; |
| TRC_init_phase1(NULL); |
| trc_register_fixed_queue(); |
| q=trc_create_queue(TRC_FIXED_QUEUE,NULL); |
| trc_assign_class_to_queue(TRC_CLASS_SYSTEM,q); |
| trc_trace_class(TRC_CLASS_SYSTEM); |
| return 0; |
| } |
| /* |
| * |
| */ |
| int main(int argc,char *argv[]) |
| { |
| // int res; |
| showmessage("This test show all filenames of a directory of an hardisk\n" |
| "recursively using a soft task for every directory.\n" |
| "The tracer with a circular queue is activated.\n"); |
| sem_init(&console,0,1); |
| sem_init(&actmutex,0,1); |
| sem_init(&actsync,0,0); |
| activate_task(-1,FROMDIR); |
| { |
| struct timespec delay; |
| delay.tv_sec = 0; |
| delay.tv_nsec = 500000000; |
| for(;;) { |
| sem_wait(&actmutex); |
| if (actcounter==0) break; |
| sem_signal(&actmutex); |
| nanosleep(&delay, NULL); |
| } |
| } |
| cprintf("\nfiles: %i\n",filecounter); |
| waitend(); |
| return 0; |
| } |
| /demos/trunk/tracer/small/initfs.c |
|---|
| 0,0 → 1,119 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: initfs.c,v 1.1 2002-11-11 07:45:05 pj Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.1 $ |
| * Last update: $Date: 2002-11-11 07:45:05 $ |
| */ |
| #include "kernel/kern.h" |
| #include "modules/edf.h" |
| #include "modules/rr.h" |
| #include "modules/cbs.h" |
| #include "modules/dummy.h" |
| #include "modules/sem.h" |
| #include "modules/hartport.h" |
| #include "modules/cabs.h" |
| #include "modules/pi.h" |
| #include "modules/pc.h" |
| #include "modules/srp.h" |
| #include "modules/npp.h" |
| #include "modules/nop.h" |
| #include "modules/nopm.h" |
| #include "drivers/keyb.h" |
| /*+ sysyem tick in us +*/ |
| #define TICK 1000 |
| /*+ RR tick in us +*/ |
| #define RRTICK 10000 |
| TIME __kernel_register_levels__(void *arg) |
| { |
| struct multiboot_info *mb = (struct multiboot_info *)arg; |
| extern int __register_sub_init_prologue(void); |
| extern int __register_sub_init(void); |
| __register_sub_init_prologue(); |
| EDF_register_level(EDF_ENABLE_ALL); |
| RR_register_level(RRTICK, RR_MAIN_YES, mb); |
| CBS_register_level(CBS_ENABLE_ALL, 0); |
| dummy_register_level(); |
| SEM_register_module(); |
| CABS_register_module(); |
| PI_register_module(); |
| PC_register_module(); |
| NPP_register_module(); |
| SRP_register_module(); |
| NOP_register_module(); |
| NOPM_register_module(); |
| __register_sub_init(); |
| return TICK; |
| } |
| TASK __init__(void *arg) |
| { |
| struct multiboot_info *mb = (struct multiboot_info *)arg; |
| KEYB_PARMS keyb = BASE_KEYB; |
| extern int __bdev_sub_init(void); |
| extern int __fs_sub_init(void); |
| extern void ctrlc_exit(KEY_EVT *k); |
| HARTPORT_init(); |
| keyb_def_ctrlC(keyb, ctrlc_exit); |
| KEYB_init(&keyb); |
| __bdev_sub_init(); |
| __fs_sub_init(); |
| __call_main__(mb); |
| return (void *)0; |
| } |
| /demos/trunk/tracer/small/test0.c |
|---|
| 0,0 → 1,71 |
| /* |
| * |
| * |
| * |
| */ |
| #include <kernel/func.h> |
| #include <fs/bdevinit.h> |
| #include <fs/fsinit.h> |
| #include <fs/bdev.h> |
| #include <drivers/keyb.h> |
| #include <sys/mount.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <string.h> |
| #include "common.h" |
| #define FILENAME "/TEMP/ALFA1.TXT" |
| #include <trace/trace.h> |
| #include <trace/queues.h> |
| int __register_sub_init_prologue(void) |
| { |
| TRC_init_phase1(NULL); |
| trc_register_fixed_queue(); |
| trc_create_queue(TRC_FIXED_QUEUE,NULL); |
| return 0; |
| } |
| int main(int argc,char *argv[]) |
| { |
| int h; |
| showmessage("A file is opened for reading while the tracer\n" |
| "with a fixed queue is runnig\n"); |
| cprintf("OPENING %s\n",FILENAME); |
| h=open(FILENAME,O_RDONLY); |
| if (h>=0) { |
| char buffer[128]; |
| int len; |
| cprintf("OPENED!\n"); |
| cprintf("READING...\n"); |
| len=read(h,buffer,sizeof(buffer)); |
| cprintf("READ %i bytes\n",len); |
| memset(buffer,'\0',sizeof(buffer)); |
| cprintf("buffer='%s'\n",buffer); |
| cprintf("READING...\n"); |
| len=read(h,buffer,sizeof(buffer)); |
| cprintf("READ %i bytes\n",len); |
| memset(buffer,'\0',sizeof(buffer)); |
| cprintf("buffer='%s'\n",buffer); |
| close(h); |
| } else |
| cprintf("FAILED!\n"); |
| waitend(); |
| return 0; |
| } |
| /demos/trunk/tracer/small/hello1.c |
|---|
| 0,0 → 1,27 |
| /* |
| * |
| * |
| * |
| */ |
| #include <ll/i386/cons.h> |
| #include <stddef.h> |
| #include <trace/trace.h> |
| #include <trace/queues.h> |
| int __register_sub_init_prologue(void) |
| { |
| TRC_init_phase1(NULL); |
| trc_register_dummy_queue(); |
| trc_create_queue(TRC_DUMMY_QUEUE,NULL); |
| return 0; |
| } |
| int main(int argc,char *argv[]) |
| { |
| cprintf("\nHello, world!\n"); |
| cprintf("The tracer has been activated!\n"); |
| cprintf("(No result are produced)\n\n"); |
| return 0; |
| } |
| /demos/trunk/tracer/small/hello2.c |
|---|
| 0,0 → 1,30 |
| /* |
| * |
| * |
| * |
| */ |
| #include <ll/i386/cons.h> |
| #include <stddef.h> |
| #include <trace/trace.h> |
| #include <trace/queues.h> |
| int __register_sub_init_prologue(void) |
| { |
| int q; |
| TRC_init_phase1(NULL); |
| trc_register_fixed_queue(); |
| q=trc_create_queue(TRC_FIXED_QUEUE,NULL); |
| trc_assign_class_to_queue(TRC_CLASS_SYSTEM,q); |
| trc_trace_class(TRC_CLASS_SYSTEM); |
| return 0; |
| } |
| int main(int argc,char *argv[]) |
| { |
| cprintf("\nHello, world!\n"); |
| cprintf("The tracer has been activated! Look at the results.\n"); |
| cprintf("(A fixed queue has been created)\n\n"); |
| return 0; |
| } |
| /demos/trunk/tracer/small/readme |
|---|
| 0,0 → 1,27 |
| This directory contains a set of tests that uses the Shark Filesystem and the tracer |
| treef1 - the test shows all filenames of a directory of an hardisk |
| recursively using a soft task for every directory. |
| The tracer with a circular queue is activated. |
| treec2 - the test shows all filenames of a directory of an hardisk |
| recursively using a soft task for every directory. |
| The tracer with a circular queue is activated that write |
| on hardisk online (while the system is running). |
| treec1 - This test show all filenames of a directory of an hardisk |
| recursively using a soft task for every directory. |
| The tracer with a circular queue is activated. |
| test0 - A file is opened for reading while the tracerwith a fixed |
| queue is runnig. |
| simple - Simple hello world (with tracer)! |
| hello - another hello world... |
| hello1 - another hello world with a dummy queue... |
| hello2 - another hello world with a fixed queue... |
| PJ |
| /demos/trunk/tracer/small/common.h |
|---|
| 0,0 → 1,28 |
| #ifndef _COMMON_H |
| #define _COMMON_H |
| #include <sys/types.h> |
| /* |
| #include <kernel/int_sem.h> |
| #define SEM internal_sem_t |
| #define sem_init internal_sem_init |
| #define sem_signal internal_sem_post |
| #define sem_wait internal_sem_wait |
| */ |
| #define SEM sem_t |
| #define sem_signal sem_post |
| extern __dev_t root_device; |
| extern __dev_t temp_device; |
| int choose_temp_callback(__dev_t dev,__uint8_t fs); |
| void showmessage(char *s); |
| void waitend(void); |
| #define FROMDIR "/TEMP" |
| #endif |
| /demos/trunk/tracer/udp/initfile.c |
|---|
| 0,0 → 1,115 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: initfile.c,v 1.2 2003-12-10 16:58:32 giacomo Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.2 $ |
| * Last update: $Date: 2003-12-10 16:58:32 $ |
| */ |
| #include "kernel/kern.h" |
| #include "modules/edf.h" |
| #include "modules/rr.h" |
| #include "modules/cbs.h" |
| #include "modules/dummy.h" |
| #include "modules/sem.h" |
| #include "modules/hartport.h" |
| #include "modules/cabs.h" |
| #include "modules/pi.h" |
| #include "modules/pc.h" |
| #include "modules/srp.h" |
| #include "modules/npp.h" |
| #include "modules/nop.h" |
| #include "modules/nopm.h" |
| #include "drivers/keyb.h" |
| /*+ sysyem tick in us +*/ |
| #define TICK 0 |
| /*+ RR tick in us +*/ |
| #define RRTICK 10000 |
| void mytracer_prologue(void); |
| void mytracer_epilogue(void); |
| TIME __kernel_register_levels__(void *arg) |
| { |
| struct multiboot_info *mb = (struct multiboot_info *)arg; |
| mytracer_prologue(); |
| EDF_register_level(EDF_ENABLE_ALL); |
| RR_register_level(RRTICK, RR_MAIN_YES, mb); |
| CBS_register_level(CBS_ENABLE_ALL, 0); |
| dummy_register_level(); |
| SEM_register_module(); |
| CABS_register_module(); |
| PI_register_module(); |
| PC_register_module(); |
| NPP_register_module(); |
| SRP_register_module(); |
| NOP_register_module(); |
| NOPM_register_module(); |
| return TICK; |
| } |
| TASK __init__(void *arg) |
| { |
| struct multiboot_info *mb = (struct multiboot_info *)arg; |
| KEYB_PARMS keyb = BASE_KEYB; |
| extern void ctrlc_exit(KEY_EVT *k); |
| HARTPORT_init(); |
| keyb_def_ctrlC(keyb, ctrlc_exit); |
| KEYB_init(&keyb); |
| mytracer_epilogue(); |
| __call_main__(mb); |
| return (void *)0; |
| } |
| /demos/trunk/tracer/udp/udptrace.c |
|---|
| 0,0 → 1,159 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * Copyright (C) 2002 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: udptrace.c,v 1.4 2003-12-10 16:58:32 giacomo Exp $ |
| */ |
| /* |
| * Example of tracer initialization. |
| */ |
| #include <ll/i386/cons.h> |
| #include <kernel/func.h> |
| #include <fs/bdevinit.h> |
| #include <fs/fsinit.h> |
| #include <fs/bdev.h> |
| #include <drivers/keyb.h> |
| #include <drivers/udpip.h> |
| #include <tracer.h> |
| #include <queues.h> |
| #include <sys/mount.h> |
| #include <stddef.h> |
| #include <string.h> |
| char myipaddr[15], toipaddr[15]; |
| void mytracer_prologue(void) |
| { |
| int myqueue; |
| TRC_PARMS p; |
| TRC_UDP_PARMS u; |
| UDP_ADDR local, remote; |
| /* these are the IP numbers of my home PCs ;-) */ |
| strcpy(myipaddr, "192.168.82.120"); |
| strcpy(toipaddr, "192.168.82.20"); |
| clear(); |
| ip_str2addr(toipaddr,&(remote.s_addr)); |
| remote.s_port = 20000; // htons is done automatically; |
| ip_str2addr(myipaddr,&(local.s_addr)); |
| local.s_port = 20000; // htons is done automatically; |
| trc_default_parms(p); |
| trc_def_path(p,""); |
| trc_udp_default_parms(u,local,remote); |
| /* Tracer Initialization */ |
| /* the first functions to call... parameters can be passed */ |
| TRC_init_phase1(&p); |
| /* all the tracer queue types must be registered */ |
| trc_register_udp_queue(); |
| /* then, we create all the queues we need */ |
| myqueue = trc_create_queue(TRC_UDP_QUEUE,&u); |
| /* Then, we say that events must be sent to a particular queue */ |
| trc_trace_class(TRC_CLASS_SYSTEM); |
| trc_assign_class_to_queue(TRC_CLASS_SYSTEM, myqueue); |
| } |
| void mytracer_epilogue(void) |
| { |
| struct net_model m = net_base; |
| /* We want a task for TX mutual exclusion */ |
| net_setmode(m, TXTASK); |
| /* We use UDP/IP stack */ |
| net_setudpip(m, myipaddr, "255.255.255.255"); |
| /* OK: let's start the NetLib! */ |
| if (net_init(&m) == 1) { |
| cprintf("udptrace: Net Init OK...\n"); |
| } else { |
| cprintf("udptrace: Net Init Failed...\n"); |
| sys_abort(300); |
| } |
| TRC_init_phase2(); |
| } |
| void ctrlc_exit(KEY_EVT *k) |
| { |
| sys_end(); |
| } |
| void *mytask(void *arg) |
| { |
| int i; |
| for(i=0; i<10; i++) { |
| cprintf("%d\n", i); |
| task_endcycle(); |
| } |
| return 0; |
| } |
| int main(int argc,char *argv[]) |
| { |
| SOFT_TASK_MODEL mp; |
| PID pid; |
| soft_task_default_model(mp); |
| soft_task_def_met(mp, 10000); |
| soft_task_def_period(mp,50000); |
| soft_task_def_usemath(mp); |
| cprintf("\nHello, world!\n"); |
| pid = task_create("mytask", mytask, &mp, NULL); |
| if (pid != NIL) task_activate(pid); |
| return 0; |
| } |
| /demos/trunk/tracer/udp/makefile |
|---|
| 0,0 → 1,21 |
| # |
| # |
| # |
| ifndef BASE |
| BASE=../../.. |
| endif |
| include $(BASE)/config/config.mk |
| PROGS= udptrace |
| include $(BASE)/config/example.mk |
| udptrace: |
| make -f $(SUBMAKE) BASE=$(BASE) APP=udptrace INIT= OTHEROBJS=initfile.o OTHERINCL="-I$(BASE)/tracer/include" SHARKOPT=__OLDCHAR__ |
| /demos/trunk/tracer/udp/readme |
|---|
| 0,0 → 1,10 |
| This is a simple test that uses the tracer. |
| The example assigns the IP address 192.168.1.2 to the machine, and |
| sends the tracer data to 192.168.1.1 using UDp, port 20000. |
| You can use demos/tracer/utils/udpdump to get the informations. |
| Enjoy, |
| PJ |
| /demos/trunk/tracer/utils/jdump.c |
|---|
| 0,0 → 1,470 |
| /* |
| * Project: HARTIK (HA-rd R-eal TI-me K-ernel) |
| * |
| * Coordinators: Giorgio Buttazzo <giorgio@sssup.it> |
| * Gerardo Lamastra <gerardo@sssup.it> |
| * |
| * Authors : Massimiliano Giorgi <massy@hartik.sssup.it> |
| * (see authors.txt for full list of hartik's authors) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://hartik.sssup.it |
| */ |
| /* |
| * Copyright (C) 1999 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| /* |
| * CVS : $Id: jdump.c,v 1.3 2003-07-24 12:22:11 giacomo Exp $ |
| * |
| * File: $File$ |
| * Revision: $Revision: 1.3 $ |
| * Last update: $Date: 2003-07-24 12:22:11 $ |
| */ |
| #include <netinet/in.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include "types.h" |
| #include <trace.h> |
| #include "util.h" |
| /* |
| * |
| * This filter converts trace file formats from SHARK to JTRACER |
| * |
| */ |
| /* All times are dived by this costant. */ |
| #define TIMESCALE 1 |
| /* If defined dump on stdout the packets (in ascii) that will be written |
| * on the output file (the file of the tracer). |
| */ |
| #define DUMPOUT |
| /* |
| * |
| * |
| * |
| */ |
| int pippo=0; |
| int writeInt(int h, int x) |
| { |
| int y,res; |
| y=htonl(x); |
| res=write(h,&y,sizeof(int)); |
| return res!=sizeof(int); |
| } |
| int writeStr(int h, char *s) |
| { |
| int res,size; |
| size=strlen(s); |
| writeInt(h,size); |
| res=write(h,s,size); |
| return res!=size; |
| } |
| /* |
| * |
| */ |
| #define TASK_ARRIVAL 0 |
| #define TASK_SCHEDULE 1 |
| #define TASK_DESCHEDULE 2 |
| #define TASK_END 3 |
| #define TASK_DLINEPOST 4 |
| #define TASK_DLINESET 5 |
| #define TASK_WAIT 6 |
| #define TASK_SIGNAL 7 |
| #define TASK_IDLE 8 |
| #define TASK_NAME 9 |
| #define EVT_NUMBER 10 |
| char *eventsname[]={ |
| "task_arrival", |
| "task_schedule", |
| "task_deschedule", |
| "task_end", |
| "task_dlinepost", |
| "task_dlineset", |
| "task_wait", |
| "task_signal", |
| "task_idle", |
| "task_name" |
| }; |
| struct j_evt_prolog { |
| int type; |
| int time; |
| }; |
| struct j_evt_task { |
| struct j_evt_prolog p; |
| int task; |
| }; |
| struct j_evt_dlinepost { |
| struct j_evt_task t; |
| int taskD; |
| int taskD2; |
| }; |
| struct j_evt_dlineset { |
| struct j_evt_task t; |
| int taskD; |
| }; |
| struct j_evt_semaph { |
| struct j_evt_task t; |
| int res; |
| char *name; |
| }; |
| struct j_evt_name { |
| struct j_evt_task t; |
| char *name; |
| }; |
| /* |
| * |
| */ |
| int j_write_prolog(int h, void *ptr) |
| { |
| #ifdef DUMPOUT |
| printf("%10i ",((struct j_evt_prolog *)ptr)->time); |
| printf("%-18s ",eventsname[((struct j_evt_prolog *)ptr)->type]); |
| #endif |
| if (writeInt(h,((struct j_evt_prolog *)ptr)->type)) return -2; |
| if (writeInt(h,((struct j_evt_prolog *)ptr)->time)) return -3; |
| return 0; |
| } |
| int j_write_task(int h, void *ptr) |
| { |
| int res; |
| res=j_write_prolog(h,ptr); |
| #ifdef DUMPOUT |
| printf("tsk=%i ",((struct j_evt_task *)ptr)->task); |
| #endif |
| if (res) return res; |
| if (writeInt(h,((struct j_evt_task *)ptr)->task)) return -4; |
| return 0; |
| } |
| int j_write_dlinepost(int h, void *ptr) |
| { |
| int res; |
| res=j_write_task(h,ptr); |
| if (res) return res; |
| if (writeInt(h,((struct j_evt_dlinepost *)ptr)->taskD)) return -5; |
| if (writeInt(h,((struct j_evt_dlinepost *)ptr)->taskD2)) return -6; |
| return 0; |
| } |
| int j_write_dlineset(int h, void *ptr) |
| { |
| int res; |
| res=j_write_task(h,ptr); |
| if (res) return res; |
| if (writeInt(h,((struct j_evt_dlineset *)ptr)->taskD)) return -7; |
| return 0; |
| } |
| int j_write_semaph(int h, void *ptr) |
| { |
| int res; |
| res=j_write_task(h,ptr); |
| if (res) return res; |
| if (writeInt(h,((struct j_evt_semaph *)ptr)->res)) return -8; |
| if (writeStr(h,((struct j_evt_semaph *)ptr)->name)) return -9; |
| return 0; |
| } |
| int j_write_name(int h, void *ptr) |
| { |
| int res; |
| res=j_write_task(h,ptr); |
| #ifdef DUMPOUT |
| printf("name='%s' ",((struct j_evt_name *)ptr)->name); |
| #endif |
| if (res) return res; |
| if (writeStr(h,((struct j_evt_name *)ptr)->name)) return -10; |
| return 0; |
| } |
| int writeEvent(int h, void *ptr) |
| { |
| int res; |
| //printf("<%i>",((struct j_evt_prolog*)ptr)->type); |
| ((struct j_evt_prolog*)ptr)->time/=TIMESCALE; |
| switch(((struct j_evt_prolog*)ptr)->type) { |
| case TASK_ARRIVAL: |
| case TASK_SCHEDULE: |
| case TASK_DESCHEDULE: |
| case TASK_END: |
| case TASK_IDLE: |
| res=j_write_task(h,ptr); |
| break; |
| case TASK_DLINEPOST: |
| res=j_write_dlinepost(h,ptr); |
| break; |
| case TASK_DLINESET: |
| res=j_write_dlineset(h,ptr); |
| break; |
| case TASK_WAIT: |
| case TASK_SIGNAL: |
| res=j_write_semaph(h,ptr); |
| break; |
| case TASK_NAME: |
| res=j_write_name(h,ptr); |
| break; |
| default: |
| return -1; |
| } |
| #ifdef DUMPOUT |
| printf(" \n"); |
| #endif |
| return res; |
| } |
| /* |
| * |
| * |
| * |
| */ |
| #define MAX_PROC 150 |
| //int activated[MAX_PROC]; |
| int cxx=0; |
| /* write MAXC-1 events */ |
| #define MAXC 10000 |
| long lasttime; |
| int sys_event(int h, void *param) |
| { |
| static int prevtask=-1; |
| trc_event_t *ptr=(trc_event_t *)param; |
| struct j_evt_task evt; |
| evt.p.time=ptr->time; |
| evt.task=ptr->x.sys.task; |
| lasttime=ptr->time; |
| switch(ptr->event) { |
| case TRC_CREATE: |
| return 0; |
| case TRC_ACTIVATE: |
| case TRC_INTACTIVATION: |
| //activated[ptr->x.sys.task]=1; |
| evt.p.type=TASK_ARRIVAL; |
| break; |
| case TRC_DESTROY: |
| //activated[ptr->x.sys.task]=0; |
| return 0; |
| case TRC_DISABLE: |
| return 0; |
| case TRC_DELAY: |
| prevtask=-1; |
| evt.p.type=TASK_DESCHEDULE; |
| break; |
| case TRC_SLEEP: |
| prevtask=-1; |
| evt.p.type=TASK_DESCHEDULE; |
| break; |
| case TRC_ENDCYCLE: |
| prevtask=-1; |
| evt.p.type=TASK_END; |
| break; |
| case TRC_SCHEDULE: |
| if (prevtask!=-1) { |
| struct j_evt_task evt2; |
| int res; |
| evt2.p.time=ptr->time; |
| evt2.p.type=TASK_DESCHEDULE; |
| evt2.task=prevtask; |
| res=writeEvent(h,&evt2); |
| if (res!=0) return -1; |
| } |
| /* |
| if (!activated[ptr->x.sys.task]) { |
| struct j_evt_task evt2; |
| evt2.p.time=ptr->time-1; |
| evt2.task=ptr->x.sys.task; |
| evt2.p.type=TASK_ARRIVAL; |
| writeEvent(h,&evt2); |
| activated[ptr->x.sys.task]=1; |
| } |
| */ |
| evt.p.type=TASK_SCHEDULE; |
| prevtask=ptr->x.sys.task; |
| break; |
| default: |
| return 0; |
| } |
| cxx++; |
| if (cxx==MAXC) return -1; |
| return writeEvent(h,&evt); |
| } |
| int sem_event(int h,void *param) |
| { |
| //trc_event_t *ptr=(trc_event_t *)param; |
| //struct j_evt_semaph evt; |
| return 0; |
| /* |
| evt.t.p.time=ptr->x.norm.when; |
| evt.t.task=ptr->x.norm.who; |
| switch(ptr->what) { |
| case TRC_SEM_WAIT: evt.t.p.type=TASK_WAIT; break; |
| case TRC_SEM_SIGNAL: evt.t.p.type=TASK_SIGNAL; break; |
| case TRC_SEM_WAITNB: return 0; |
| default: return 0; |
| } |
| evt.res=1; |
| evt.name="NoName"; |
| return j_write_semaph(h,&evt); |
| */ |
| } |
| /* -- */ |
| #define MAX_PROC 150 |
| int names[MAX_PROC]; |
| int outfile; |
| int dumpfunc(trc_event_t *ptr) |
| { |
| //printf("{%i}",ptr->event); |
| if (!names[ptr->x.sys.task]) { |
| struct j_evt_name evtname; |
| static char name[24]; |
| cxx++; |
| if (cxx==MAXC) return -1; |
| evtname.t.p.time=lasttime; |
| evtname.t.task=ptr->x.sys.task; |
| evtname.t.p.type=TASK_NAME; |
| sprintf(name,"task%03i",ptr->x.sys.task); |
| evtname.name=name; |
| writeEvent(outfile,&evtname); |
| names[ptr->x.sys.task]=1; |
| } |
| switch(event_class(ptr->event)) { |
| case TRC_CLASS_SYSTEM: |
| return sys_event(outfile,ptr); |
| case TRC_CLASS_SEM: |
| return 0; |
| return sem_event(outfile,ptr); |
| case TRC_CLASS_USER: |
| return 0; |
| } |
| return 0; |
| } |
| /* |
| * |
| */ |
| #ifndef O_BINARY |
| #define O_BINARY 0 |
| #endif |
| int main(int argc, char *argv[]) |
| { |
| int res; |
| int i; |
| if (argc!=3) { |
| fprintf(stderr,"missing filenames\n"); |
| fprintf(stderr,"usage: jdump SHARKtracefilename JTRACERtracefilename\n"); |
| return -1; |
| } |
| for (i=0;i<MAX_PROC;i++) { |
| names[i]=0; |
| //activated[i]=0; |
| } |
| outfile=open(argv[2],O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,0777); |
| if (outfile==-1) { |
| perror("can't open outfile"); |
| return -1; |
| } |
| res=read_trace(argv[1],dumpfunc); |
| close(outfile); |
| //fprintf(stderr,"result=%i",res); |
| return 0; |
| } |
| /demos/trunk/tracer/utils/makefile |
|---|
| 0,0 → 1,70 |
| # |
| # util -> compiles the tracer utilities under MSDOS/DJGPP |
| # util_linux -> compiles the tracer utilities under Linux |
| # |
| ifndef BASE |
| BASE=../../.. |
| endif |
| .PHONY: util_dos util_linux clean |
| all: |
| @echo Targets: util_dos util_linux clean |
| @echo Note: udpdump is available only under linux |
| util_dos: tdump.exe jdump.exe sa.exe road.exe wait.exe |
| tdump.exe: tdump.c util.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace tdump.c util.c -o tdump.exe |
| jdump.exe: jdump.c util.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace jdump.c util.c -o jdump.exe |
| sa.exe: sa.c util.c distr.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace sa.c util.c -o sa.exe |
| road.exe: road.c util.c distr.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace road.c util.c -o road.exe |
| wait.exe: wait.c util.c distr.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace wait.c util.c -o wait.exe |
| util_linux: jdump tdump sa road wait udpdump |
| jdump: jdump.c util.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace -I$(BASE)/oslib jdump.c util.c -o jdump |
| tdump: tdump.c util.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace -I$(BASE)/oslib tdump.c util.c -o tdump |
| sa: sa.c util.c distr.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace -I$(BASE)/oslib sa.c util.c -o sa |
| road: road.c util.c distr.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace -I$(BASE)/oslib road.c util.c -o road |
| wait: wait.c util.c distr.c |
| gcc -s -Wimplicit-function-declaration -Wall \ |
| -I$(BASE)/include/trace -I$(BASE)/oslib wait.c util.c -o wait |
| udpdump: udpdump.c util.c |
| gcc -Wimplicit-function-declaration -Wall -ggdb\ |
| -I$(BASE)/include/trace -I$(BASE)/oslib udpdump.c util.c -o udpdump |
| clean: |
| rm -rf *.o jdump tdump sa road wait tdump.exe jdump.exe sa.exe road.exe wait.exe |
| /demos/trunk/tracer/utils/util.c |
|---|
| 0,0 → 1,203 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * Copyright (C) 2002 Paolo Gai |
| * Copyright (C) 2002 Tomas Lenvall |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: util.c,v 1.3 2003-07-24 12:22:11 giacomo Exp $ |
| */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <stdlib.h> |
| #include "types.h" |
| #include <trace.h> |
| #include <types.h> |
| static char *names[]={ |
| "reserved", |
| "hoops", |
| /*--*/ |
| "create", |
| "activate", |
| "schedule", |
| "delay", |
| "sleep", |
| "endcycle", |
| "destroy", |
| "intactiv", |
| "disable", |
| /*--*/ |
| "user0", |
| "user1", |
| "user2", |
| "user3", |
| "user4", |
| "user5", |
| "user6", |
| "user7", |
| /*--*/ |
| "wait", |
| "waitnb", |
| "signal" |
| }; |
| int classtable[TRC_NUMCLASSES+1]={ |
| TRC_F_TRACER, |
| TRC_F_SYSTEM, |
| TRC_F_USER, |
| TRC_F_SEM, |
| TRC_F_LAST |
| }; |
| int event_class(int ev) |
| { |
| int i; |
| if (ev < 0 || ev >= TRC_NUMEVENTS) |
| return -1; |
| for (i = 0; i < TRC_NUMCLASSES; i++) |
| if (ev >= classtable[i] && ev < classtable[i+1]) |
| return i; |
| return -1; |
| } |
| char *event_name(int ev) |
| { |
| if (ev<0||ev>=TRC_NUMEVENTS) return "unknown"; |
| return names[ev]; |
| } |
| char *event_hexdump(u_int8_t *ptr,int maxsize) |
| { |
| static char buffer[256]; |
| int i; |
| for (i=0;i<maxsize;i++) sprintf(buffer+i*2,"%02x",*(ptr+i)); |
| buffer[maxsize*2]='\0'; |
| return buffer; |
| } |
| char *event_strdump(u_int8_t *ptr, int maxsize) |
| { |
| static char buffer[256]; |
| memcpy(buffer,ptr,maxsize); |
| buffer[maxsize]='\0'; |
| return buffer; |
| } |
| char *format_time(long time) |
| { |
| static char buffer[256]; |
| if (time<1000l) { |
| sprintf(buffer,"%li",time); |
| return buffer; |
| } |
| if (time<1000000l) { |
| sprintf(buffer,"%li,%03li",time/1000l,time%1000l); |
| return buffer; |
| } |
| sprintf(buffer,"%li,%03li,%03li", |
| (time/1000000l), |
| (time%1000000l)/1000l, |
| time%1000l); |
| return buffer; |
| } |
| #ifndef O_BINARY |
| #define O_BINARY 0 |
| #endif |
| int read_trace(char *filename,int (*func)(trc_event_t *)) |
| { |
| trc_event_t buffer; |
| int fin; |
| int res; |
| fin=open(filename,O_RDONLY|O_BINARY); |
| if (fin==-1) return -1; |
| for (;;) { |
| res=read(fin,&buffer,sizeof(trc_event_t)); |
| if (res!=sizeof(trc_event_t)) { |
| close(fin); |
| return res==0?0:-2; |
| } |
| res=(*func)(&buffer); |
| if (res!=0) { |
| close(fin); |
| return res; |
| } |
| } |
| close(fin); |
| return 0; |
| } |
| /* reads trace events from a udp message */ |
| int read_udp_trace(char *msg, int (*func)(trc_event_t *)) |
| { |
| short int events; // temporary storage of nr of events |
| int res; |
| /* message: |
| |2 bytes=nr of events|12 bytes=event 0|12 bytes=event 1|... |
| Note: the size of an event depends on the extra informations that |
| are put on the trc_event_t data structures. That size is |
| currently 12 bytes, but it can change if additional fields are |
| added to the trc_event_t structure. Including the |
| include/trace/types.h header ensures that the size used in this |
| application is coherent with the size of the compiled Shark |
| applications... |
| */ |
| events = *((short int *)msg); |
| msg += 2; // skip the 2 first bytes |
| for (; |
| events > 0; |
| events--, msg += sizeof(trc_event_t)) |
| res = (*func)((trc_event_t *)msg); |
| return 1; |
| } |
| /demos/trunk/tracer/utils/udpdump.c |
|---|
| 0,0 → 1,216 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * Copyright (C) 2002 Paolo Gai |
| * Copyright (C) 2002 Tomas Lenvall |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: udpdump.c,v 1.1 2002-10-28 08:07:32 pj Exp $ |
| */ |
| /* this example simply prints a Shark trace file */ |
| // INCLUDES |
| #include <netinet/in.h> |
| #include "types.h" |
| #include "trace.h" |
| #include "util.h" |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| #include <netdb.h> |
| #include <stdio.h> |
| #include <unistd.h>/* close() */ |
| #include <string.h> /* memset() */ |
| #include <stdlib.h> |
| // GLOBALS |
| char server_ipaddr[20]; // Store the IP adress of the server |
| // DEFINES |
| #define LOCAL_SERVER_PORT 20000 |
| #define MAX_MSG 10000 |
| // FUNCTIONS |
| /* */ |
| int dumpsys(trc_system_event_t *sys) |
| { |
| printf("%02i\n",sys->task); |
| return 0; |
| } |
| /* */ |
| int dumpusr(trc_user_event_t *usr) |
| { |
| printf("%8li ",usr->n); |
| printf("\n"); |
| return 0; |
| } |
| /* */ |
| int dumpsem(trc_sem_event_t *sem) |
| { |
| printf("on [%i]\n",sem->id); |
| return 0; |
| } |
| /* */ |
| int dumpfunc(trc_event_t *ev) |
| { |
| static int counter=0; |
| printf("\t%4i ",counter); |
| counter++; |
| printf("%12s ",format_time(ev->time)); |
| printf("%-10s ",event_name(ev->event)); |
| //printf("%08x\n",(unsigned)ev->sys.event); |
| //return 0; |
| switch(event_class(ev->event)) { |
| case TRC_CLASS_SYSTEM: return dumpsys(&ev->x.sys); |
| case TRC_CLASS_USER: return dumpusr(&ev->x.usr); |
| case TRC_CLASS_SEM: return dumpsem(&ev->x.sem); |
| } |
| printf("\nEVENT %i... CLASS %i UNKNOWN!\n",ev->event,event_class(ev->event)); |
| return -1; |
| } |
| /* Use UDP/IP to receive the events from the client computer */ |
| int main(int argc, char *argv[]) |
| { |
| int sd, rc, n, cliLen; |
| struct sockaddr_in cliAddr, servAddr; |
| char msg[MAX_MSG]; |
| // socket creation |
| sd = socket(AF_INET, SOCK_DGRAM, 0); |
| if(sd < 0) { |
| printf("%s: cannot open socket \n",argv[0]); |
| exit(1); |
| } |
| // bind local server port |
| servAddr.sin_family = AF_INET; |
| servAddr.sin_addr.s_addr = htonl(INADDR_ANY); |
| servAddr.sin_port = htons(LOCAL_SERVER_PORT); |
| rc = bind (sd, (struct sockaddr *)&servAddr,sizeof(servAddr)); |
| if(rc < 0) { |
| printf("%s: cannot bind port number %d \n", |
| argv[0], LOCAL_SERVER_PORT); |
| exit(1); |
| } |
| while(1){ |
| // init buffer |
| memset(msg, 0x0, MAX_MSG); |
| // receive message |
| cliLen = sizeof(cliAddr); |
| n = recvfrom(sd, msg, MAX_MSG, 0,(struct sockaddr *)&cliAddr, &cliLen); |
| printf("Packet received, length %d, %d tracer events.\n", n, |
| *((short int *)msg)); |
| if(n < 0) { |
| printf("%s: cannot receive data \n",argv[0]); |
| continue; |
| } |
| // Read the trace we got from the network |
| read_udp_trace(msg, dumpfunc); |
| } |
| return 0; |
| } |
| // test main: testing this program from a file (simulating a network package) |
| // ONLY USED FOR TESTING!!! |
| /*int main(int argc, char *argv[]) |
| { |
| FILE* fin; |
| int nr_of_events = 0; |
| trc_event_t buffer; |
| char all_events[1000]; |
| char tmpbuf[2]; |
| if(argc != 2) { |
| printf("Missing filename!\n"); |
| return -1; |
| } |
| // open the file and send event by event |
| fin = fopen(argv[1], "r"); |
| if (fin == NULL) { |
| printf("Cannot open file\n"); |
| return -1; |
| } |
| // check how many events |
| while (!feof(fin)) { |
| fread(&buffer, sizeof(trc_event_t), 1, fin); |
| nr_of_events++; |
| } |
| //printf("Nr of events: %d\n", nr_of_events); |
| rewind(fin); // start from the beginning again... |
| //strncpy(tmpbuf, itoa(nr_of_events), 2); |
| sprintf(tmpbuf, "%d", nr_of_events); |
| //printf("tmpbuf: %s\n", tmpbuf); |
| memset(all_events, 0, 1000); |
| memcpy(all_events, tmpbuf, 2); |
| printf("all_events(1): %s\n", all_events); |
| // read all tracer events and store them in an array |
| fread(all_events + 2, sizeof(trc_event_t), nr_of_events, fin); |
| fclose(fin); |
| printf("all_events(2): %s\n", all_events); |
| // send it to the event reader |
| read_trace(all_events, dumpfunc); |
| return 1; |
| } |
| */ |
| /demos/trunk/tracer/utils/util.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * Copyright (C) 2002 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: util.h,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| #ifndef __UTIL_H |
| #define __UTIL_H |
| #include "types.h" |
| char *event_name(int evt); |
| char *event_hexdump(u_int8_t *ptr, int maxsize); |
| char *event_strdump(u_int8_t *ptr, int maxsize); |
| int event_class(int evt); |
| int read_trace(char *filename,int (*func)(trc_event_t *)); |
| int read_udp_trace(void *msg, int (*func)(trc_event_t *)); |
| char *format_time(long time); |
| #endif |
| /demos/trunk/tracer/utils/sa.c |
|---|
| 0,0 → 1,120 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: sa.c,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| #include <netinet/in.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include "types.h" |
| #include <trace.h> |
| #include "util.h" |
| /* this file prints the distribution of (schedule_time - arrival_time) */ |
| #define MAXX 50 |
| #define PREC 100 |
| #define DELTA ((double)MAXX/(double)PREC) |
| #include "distr.c" |
| int task; |
| long a=-1; |
| long s; |
| int safunc(trc_event_t *ev) |
| { |
| if (event_class(ev->event)!=TRC_CLASS_SYSTEM) return 0; |
| if (ev->x.sys.task!=task) return 0; |
| if (a==-1) { |
| if (ev->event==TRC_ACTIVATE||ev->event==TRC_INTACTIVATION) |
| a=ev->time; |
| } else { |
| if (ev->event==TRC_SCHEDULE) { |
| s=ev->time; |
| d_insert(s-a); |
| a=-1; |
| } |
| } |
| return 0; |
| } |
| /* -- */ |
| int main(int argc, char *argv[]) |
| { |
| int res; |
| if (argc!=4) { |
| fprintf(stderr,"usage: sa [tracefile] [pid] [outputfile]\n"); |
| return -1; |
| } |
| d_init(); |
| task=atoi(argv[2]); |
| res=read_trace(argv[1],safunc); |
| if (res==0) { |
| FILE *fout; |
| fout=fopen(argv[3],"wt"); |
| if (fout==NULL) { |
| fprintf(stderr,"error writing output file!\n"); |
| return 0; |
| } |
| d_dump(fout); |
| fclose(fout); |
| } |
| if (res!=0) { |
| fprintf(stderr,"error=%i\n",res); |
| perror("ERROR"); |
| } |
| return 0; |
| } |
| /demos/trunk/tracer/utils/wait.c |
|---|
| 0,0 → 1,95 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: wait.c,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "types.h" |
| #include <trace.h> |
| #include "util.h" |
| /* This demo computes the distribution of the wait times on disk requests */ |
| #define MAXX 37000 |
| #define PREC 37000 |
| #define DELTA ((double)MAXX/(double)PREC) |
| #include "distr.c" |
| int task; |
| long a=-1; |
| int waitfunc(trc_event_t *ev) |
| { |
| if (event_class(ev->event)!=TRC_CLASS_USER) return 0; |
| if (ev->x.usr.n!=task) return 0; |
| if (ev->event==TRC_USER1) { |
| a=ev->time; |
| return 0; |
| } |
| if (ev->event==TRC_USER2) { |
| if (a!=-1) d_insert(ev->time-a); |
| a=-1; |
| } |
| return 0; |
| } |
| int main(int argc, char *argv[]) |
| { |
| FILE *fout; |
| int res; |
| if (argc!=4) { |
| fprintf(stderr,"missing filename!\n"); |
| return -1; |
| } |
| d_init(); |
| task=atoi(argv[2]); |
| res=read_trace(argv[1],waitfunc); |
| if (res==0) { |
| fout=fopen(argv[3],"wt"); |
| if (fout!=NULL) { |
| d_dump(fout); |
| fclose(fout); |
| } else |
| fprintf(stderr,"can't create output file!\n"); |
| } else |
| fprintf(stderr,"read_trace error\n"); |
| return 0; |
| } |
| /demos/trunk/tracer/utils/distr.c |
|---|
| 0,0 → 1,83 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: distr.c,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| long t[PREC]; |
| long counter; |
| long hoops; |
| long maxv=0; |
| void d_init(void) |
| { |
| int i; |
| hoops=counter=0; |
| for (i=0;i<PREC;i++) t[i]=0; |
| } |
| void d_insert(long d) |
| { |
| if (d>=MAXX) { |
| hoops++; |
| if (d>maxv) maxv=d; |
| return; |
| } |
| counter++; |
| t[(int)(d/DELTA)]++; |
| } |
| void d_dump(FILE *fout) |
| { |
| int i; |
| if (counter==0) { |
| fprintf(stderr,"nothing to write to the output file\n"); |
| return; |
| } |
| if (hoops) { |
| fprintf(stderr,"%li values to big (max=%li)\n",hoops,maxv); |
| } |
| for (i=0;i<PREC;i++) |
| fprintf(fout,"%f %f\n", |
| DELTA/2.0+DELTA*i, |
| (double)t[i]/(double)counter |
| ); |
| } |
| /demos/trunk/tracer/utils/road.c |
|---|
| 0,0 → 1,96 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: road.c,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "types.h" |
| #include <trace.h> |
| #include "util.h" |
| /* this test prints the distribution of the HD seeks */ |
| #define MAXX 1000 |
| #define PREC 1000 |
| #define DELTA ((double)MAXX/(double)PREC) |
| #include "distr.c" |
| int dumpusr(int event, trc_user_event_t *usr) |
| { |
| static long last=-1; |
| long d; |
| if (event!=TRC_USER0) return 0; |
| if (last!=-1) { |
| d=abs(last-usr->n); |
| d_insert(d); |
| } |
| last=usr->n; |
| return 0; |
| } |
| int dumpfunc(trc_event_t *ev) |
| { |
| if (event_class(ev->event)==TRC_CLASS_USER) dumpusr(ev->event,&ev->x.usr); |
| return 0; |
| } |
| int main(int argc, char *argv[]) |
| { |
| FILE *fout; |
| int res; |
| if (argc!=3) { |
| fprintf(stderr,"missing filename!\n"); |
| return -1; |
| } |
| d_init(); |
| res=read_trace(argv[1],dumpfunc); |
| if (res==0) { |
| fout=fopen(argv[2],"wt"); |
| if (fout!=NULL) { |
| d_dump(fout); |
| fclose(fout); |
| } else |
| fprintf(stderr,"can't create output file!\n"); |
| } else |
| fprintf(stderr,"read_trace error\n"); |
| return 0; |
| } |
| /demos/trunk/tracer/utils/tdump.c |
|---|
| 0,0 → 1,115 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * Copyright (C) 2002 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: tdump.c,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| /* this example simply prints a Shark trace file */ |
| #include <netinet/in.h> |
| #include <stdio.h> |
| #include "types.h" |
| #include <trace.h> |
| #include "util.h" |
| int dumpsys(trc_system_event_t *sys) |
| { |
| /* |
| if (sys->event==TRC_SCHEDULE) { |
| //if (sys->prev!=65535) |
| // printf("%02i->%02i\n",sys->prev,sys->task); |
| //else |
| printf("??->%02i\n",sys->task); |
| return 0; |
| } |
| */ |
| printf("%02i\n",sys->task); |
| return 0; |
| } |
| int dumpusr(trc_user_event_t *usr) |
| { |
| printf("%8li ",usr->n); |
| printf("\n"); |
| return 0; |
| } |
| int dumpsem(trc_sem_event_t *sem) |
| { |
| printf("on [%i]\n",sem->id); |
| return 0; |
| } |
| int dumpfunc(trc_event_t *ev) |
| { |
| static int counter=0; |
| printf("%4i ",counter); |
| counter++; |
| printf("%12s ",format_time(ev->time)); |
| printf("%-10s ",event_name(ev->event)); |
| //printf("%08x\n",(unsigned)ev->sys.event); |
| //return 0; |
| switch(event_class(ev->event)) { |
| case TRC_CLASS_SYSTEM: return dumpsys(&ev->x.sys); |
| case TRC_CLASS_USER: return dumpusr(&ev->x.usr); |
| case TRC_CLASS_SEM: return dumpsem(&ev->x.sem); |
| } |
| printf("\nEVENT %i... CLASS %i UNKNOWN!\n",ev->event,event_class(ev->event)); |
| return -1; |
| } |
| int main(int argc, char *argv[]) |
| { |
| int res; |
| if (argc!=2) { |
| fprintf(stderr,"missing filename!\n"); |
| return -1; |
| } |
| res=read_trace(argv[1],dumpfunc); |
| //fprintf(stderr,"result=%i\n",res); |
| //fprintf(stderr,"size=%li\n",sizeof(trc_event_t)); |
| return 0; |
| } |
| /demos/trunk/tracer/utils/types.h |
|---|
| 0,0 → 1,55 |
| /* |
| * Project: S.Ha.R.K. |
| * |
| * Coordinators: |
| * Giorgio Buttazzo <giorgio@sssup.it> |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * |
| * Authors : |
| * Paolo Gai <pj@gandalf.sssup.it> |
| * Massimiliano Giorgi <massy@gandalf.sssup.it> |
| * Luca Abeni <luca@gandalf.sssup.it> |
| * (see the web pages for full authors list) |
| * |
| * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
| * |
| * http://www.sssup.it |
| * http://retis.sssup.it |
| * http://shark.sssup.it |
| */ |
| /* |
| * Copyright (C) 2000 Massimiliano Giorgi |
| * Copyright (C) 2002 Paolo Gai |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * CVS : $Id: types.h,v 1.2 2002-10-28 08:07:32 pj Exp $ |
| */ |
| #ifndef __TYPES_H__ |
| #define __TYPES_H__ |
| #include <sys/types.h> |
| /* when compiling under MSDOS, uncomment this three typedefs!!! */ |
| //typedef unsigned char u_int8_t; |
| //typedef unsigned short u_int16_t; |
| //typedef unsigned long u_int32_t; |
| #include <types.h> |
| #endif |
| /demos/trunk/tracer/utils/readme |
|---|
| 0,0 → 1,13 |
| This directory contains a set of utilities that can be used to interpret |
| the tracer output: |
| - tdump this example simply prints a Shark trace file |
| - jdump converts trace file formats from SHARK to JTRACER |
| - sa prints the distribution of (schedule_time - arrival_time) |
| - road prints the distribution of the HD seeks |
| - wait computes the distribution of the wait times on disk requests |
| Under Linux: to compile, type "make util_linux" |
| Under MSDOS: uncomment the three lines into types.h, then type "make util_dos" |
| PJ |
| /demos/trunk/tracer/makefile |
|---|
| 0,0 → 1,11 |
| .PHONY: all clean |
| all: |
| make -C dfixed |
| make -C small |
| make -C udp |
| clean: |
| make -C dfixed clean |
| make -C small clean |
| make -C udp clean |
| /demos/trunk/tracer/readme |
|---|
| 0,0 → 1,14 |
| This directory contains a set of sub directories containing all the tracer |
| examples and utilities. |
| Here a short description of the contents |
| utils - some small utilities that can read tracer files |
| dfixed - a small applications that defines a tracer queue. |
| At the end a file is written (using DOSFS). |
| small - a set of small examples of tracer usage (using the Shark Filesystem) |
| udp - a small application that sends its trace data through the network |
| Enjoy |
| PJ |