Merge from ASPLOS tree.
authorSimon Peter <speter@inf.ethz.ch>
Tue, 2 Aug 2011 15:19:48 +0000 (17:19 +0200)
committerSimon Peter <speter@inf.ethz.ch>
Tue, 2 Aug 2011 15:19:48 +0000 (17:19 +0200)
411 files changed:
AUTHORS
capabilities/caps.hl
devices/Hakefile
devices/eMAC.dev [new file with mode: 0644]
devices/xapic.dev
errors/errno.fugu
hake/Config.hs.template
hake/SCC.hs
hake/X86_32.hs
hake/X86_64.hs
hake/menu.lst.scc
hake/menu.lst.x86_64
hake/symbolic_targets.mk
if/Hakefile
if/bcache.if [new file with mode: 0644]
if/ether_control.if
if/mem.if
if/monitor.if
if/monitor_blocking.if
if/nameservice.if
if/netd.if
if/spawn.if
if/unixsock.if [new file with mode: 0644]
include/arch/cc.h
include/arch/sys_arch.h
include/arch/x86/barrelfish_kpi/perfmon.h [new file with mode: 0644]
include/arch/x86_32/barrelfish/invocations_arch.h
include/arch/x86_32/barrelfish_kpi/shared_mem_arch.h
include/arch/x86_64/barrelfish/invocations_arch.h
include/arpa/inet.h [new file with mode: 0644]
include/barrelfish/bulk_transfer.h
include/barrelfish/caddr.h
include/barrelfish/core_state.h
include/barrelfish/debug.h
include/barrelfish/dispatcher.h
include/barrelfish/domain.h
include/barrelfish/lmp_chan.h
include/barrelfish/lmp_endpoints.h
include/barrelfish/monitor_client.h
include/barrelfish/nameservice_client.h
include/barrelfish/net_constants.h [new file with mode: 0644]
include/barrelfish/ram_alloc.h
include/barrelfish/spawn_client.h
include/barrelfish/sys_debug.h
include/barrelfish/thread_sync.h [new file with mode: 0644]
include/barrelfish/threads.h
include/barrelfish/types.h
include/barrelfish/vspace.h
include/barrelfish/vspace_common.h
include/barrelfish_kpi/capabilities.h
include/barrelfish_kpi/init.h
include/barrelfish_kpi/sys_debug.h
include/cpiobin.h
include/dmalloc/dmalloc.h [new file with mode: 0644]
include/ethersrv/ethersrv.h
include/fcntl.h [new file with mode: 0644]
include/flounder/flounder_support.h
include/grp.h [new file with mode: 0644]
include/hashtable/dictionary.h [new file with mode: 0644]
include/hashtable/hashtable.h [new file with mode: 0644]
include/hashtable/multimap.h [new file with mode: 0644]
include/locale.h
include/lwip/api.h
include/lwip/api_msg.h
include/lwip/dhcp.h
include/lwip/err.h
include/lwip/netdb.h
include/lwip/opt.h
include/lwip/sock_serialise.h [new file with mode: 0644]
include/lwip/sockets.h
include/lwip/sys.h
include/lwip/tcp.h
include/lwip/tcpip.h
include/lwipopts.h
include/mm/mm.h
include/netdb.h [new file with mode: 0644]
include/netinet/in.h [new file with mode: 0644]
include/nfs/nfs.h
include/nfs/xdr.h
include/posixcompat.h [new file with mode: 0644]
include/pwd.h [new file with mode: 0644]
include/semaphore.h [new file with mode: 0644]
include/signal.h
include/spawndomain/spawndomain.h
include/stdarg.h
include/stddef.h
include/stdio.h
include/stdio_file.h
include/stdlib.h
include/sys/_sigset.h [new file with mode: 0644]
include/sys/_types.h
include/sys/file.h [new file with mode: 0644]
include/sys/ioctl.h [new file with mode: 0644]
include/sys/ipc.h [new file with mode: 0644]
include/sys/param.h [new file with mode: 0644]
include/sys/shm.h [new file with mode: 0644]
include/sys/socket.h [new file with mode: 0644]
include/sys/stat.h
include/sys/termios.h [new file with mode: 0644]
include/sys/time.h
include/sys/times.h [new file with mode: 0644]
include/sys/types.h
include/sys/un.h [new file with mode: 0644]
include/sys/wait.h [new file with mode: 0644]
include/time.h
include/trace/trace.h
include/unistd.h
include/vfs/vfs.h
include/vfs/vfs_path.h
kernel/Hakefile
kernel/arch/arm/syscall.c
kernel/arch/scc/rck.c
kernel/arch/x86/apic.c
kernel/arch/x86/perfmon.c [new file with mode: 0644]
kernel/arch/x86/perfmon_amd.c
kernel/arch/x86/perfmon_intel.c
kernel/arch/x86_32/init.c
kernel/arch/x86_32/irq.c
kernel/arch/x86_32/startup_arch.c
kernel/arch/x86_32/syscall.c
kernel/arch/x86_64/init.c
kernel/arch/x86_64/irq.c
kernel/arch/x86_64/syscall.c
kernel/capabilities.c
kernel/dispatch.c
kernel/include/arch/scc/rck.h
kernel/include/arch/x86/apic.h
kernel/include/arch/x86/perfmon.h [new file with mode: 0644]
kernel/include/arch/x86/perfmon_amd.h
kernel/include/arch/x86/perfmon_intel.h
kernel/include/capabilities.h
kernel/include/mdb.h
kernel/include/wakeup.h
kernel/mdb.c
kernel/printf.c
kernel/schedule_rbed.c.prio_boost [new file with mode: 0644]
kernel/startup.c
kernel/syscall.c
kernel/wakeup.c
lib/barrelfish/arch/x86/perfmon.c
lib/barrelfish/arch/x86_32/sys_debug.c
lib/barrelfish/arch/x86_64/dispatch.c
lib/barrelfish/bulk_transfer.c
lib/barrelfish/capabilities.c
lib/barrelfish/debug.c
lib/barrelfish/dispatch.c
lib/barrelfish/domain.c
lib/barrelfish/flounder_support.c
lib/barrelfish/include/waitset_chan.h
lib/barrelfish/init.c
lib/barrelfish/lmp_chan.c
lib/barrelfish/lmp_endpoints.c
lib/barrelfish/monitor_client.c
lib/barrelfish/morecore.c
lib/barrelfish/nameservice_client.c
lib/barrelfish/ram_alloc.c
lib/barrelfish/spawn_client.c
lib/barrelfish/target/x86_32/pmap_target.c
lib/barrelfish/vspace/mmu_aware.c
lib/barrelfish/vspace/utils.c
lib/barrelfish/vspace/vspace.c
lib/barrelfish/waitset.c
lib/bfdmuxtools/codegen.c
lib/bfdmuxtools/tools.c
lib/bfdmuxvm/vm.c
lib/c/Hakefile
lib/c/src/_fread.c
lib/c/src/_srefill.c
lib/c/src/exit.c
lib/c/src/fflush.c
lib/c/src/fgets.c
lib/c/src/fputc.c
lib/c/src/fread.c
lib/c/src/fs-barrelfish/fopen.c
lib/c/src/fscanf.c
lib/c/src/getenv.c
lib/c/src/local.h
lib/c/src/locale.c
lib/c/src/malloc.c
lib/c/src/memcpy.c
lib/c/src/rand.c
lib/c/src/realloc.c
lib/c/src/remove.c
lib/c/src/rename.c
lib/c/src/scanf.c
lib/c/src/sscanf.c
lib/c/src/sys-barrelfish/sys_morecore.c
lib/c/src/time.c
lib/c/src/vfscanf.c
lib/c/src/vsscanf.c
lib/cpio/cpiobin.c
lib/crt/README [new file with mode: 0644]
lib/crt/crtbegin.c
lib/crt/crtend.c
lib/dmalloc/Hakefile [new file with mode: 0644]
lib/dmalloc/dmalloc.c [new file with mode: 0644]
lib/ethersrv/ethersrv.c
lib/ethersrv/ethersrv_debug.h
lib/hashtable/Hakefile [new file with mode: 0644]
lib/hashtable/hashtable.c [new file with mode: 0644]
lib/lwip/Hakefile
lib/lwip/src/api/api_lib.c
lib/lwip/src/api/api_msg.c
lib/lwip/src/api/sockets.c
lib/lwip/src/api/tcpip.c
lib/lwip/src/barrelfish/idc_barrelfish.c
lib/lwip/src/barrelfish/idc_barrelfish.h
lib/lwip/src/barrelfish/lwip_barrelfish_debug.h
lib/lwip/src/barrelfish/mem_barrelfish.c
lib/lwip/src/barrelfish/mem_barrelfish.h
lib/lwip/src/core/dns.c
lib/lwip/src/core/init.c
lib/lwip/src/core/ipv4/icmp.c
lib/lwip/src/core/mem.c
lib/lwip/src/core/memp.c
lib/lwip/src/core/pbuf.c
lib/lwip/src/core/tcp.c
lib/lwip/src/core/tcp_in.c
lib/lwip/src/netif/bfeth.c
lib/lwip/src/sys_arch.c
lib/mm/mm.c
lib/nfs/nfs.c
lib/nfs/rpc.c
lib/nfs/xdr.c
lib/posixcompat/Hakefile
lib/posixcompat/README [new file with mode: 0644]
lib/posixcompat/access.c
lib/posixcompat/chdir.c
lib/posixcompat/chmod.c
lib/posixcompat/close.c
lib/posixcompat/dirent.c
lib/posixcompat/dup.c
lib/posixcompat/dup2.c
lib/posixcompat/fcntl.c [new file with mode: 0644]
lib/posixcompat/fdtab.c
lib/posixcompat/fdtab.h
lib/posixcompat/fileno.c
lib/posixcompat/fstat.c
lib/posixcompat/fsync.c [new file with mode: 0644]
lib/posixcompat/getcwd.c
lib/posixcompat/geteuid.c [new file with mode: 0644]
lib/posixcompat/gethostid.c
lib/posixcompat/getpid.c [new file with mode: 0644]
lib/posixcompat/gettimeofday.c [new file with mode: 0644]
lib/posixcompat/grp.c [new file with mode: 0644]
lib/posixcompat/inheritance.c [new file with mode: 0644]
lib/posixcompat/ioctl.c [new file with mode: 0644]
lib/posixcompat/kill.c [new file with mode: 0644]
lib/posixcompat/link.c [new file with mode: 0644]
lib/posixcompat/lseek.c
lib/posixcompat/mkdir.c
lib/posixcompat/open.c
lib/posixcompat/posixcompat.h
lib/posixcompat/process.c
lib/posixcompat/random.c [new file with mode: 0644]
lib/posixcompat/read.c
lib/posixcompat/remove.c [new file with mode: 0644]
lib/posixcompat/rename.c [new file with mode: 0644]
lib/posixcompat/select.c [new file with mode: 0644]
lib/posixcompat/semaphore.c [new file with mode: 0644]
lib/posixcompat/setitimer.c [new file with mode: 0644]
lib/posixcompat/shm.c [new file with mode: 0644]
lib/posixcompat/signal.c
lib/posixcompat/sockets.c [new file with mode: 0644]
lib/posixcompat/stat.c
lib/posixcompat/time.c [new file with mode: 0644]
lib/posixcompat/umask.c
lib/posixcompat/unixsock.h [new file with mode: 0644]
lib/posixcompat/unlink.c
lib/posixcompat/wait.c [new file with mode: 0644]
lib/posixcompat/write.c
lib/spawndomain/spawn.c
lib/timer/timer.c
lib/vfs/Hakefile
lib/vfs/cache.c [new file with mode: 0644]
lib/vfs/fopen.c
lib/vfs/vfs.c
lib/vfs/vfs_backends.h
lib/vfs/vfs_nfs.c
lib/vfs/vfs_nfs.h [new file with mode: 0644]
lib/vfs/vfs_ops.h
lib/vfs/vfs_path.c
lib/vfs/vfs_ramfs.c
tools/demo/Aquarium/Aquarium.sln [new file with mode: 0644]
tools/demo/Aquarium/obj/Debug/App.g.cs [new file with mode: 0644]
tools/demo/Aquarium/obj/Debug/Aquarium.csproj.FileListAbsolute.txt [new file with mode: 0644]
tools/demo/Aquarium/obj/Debug/Aquarium_MarkupCompile.cache [new file with mode: 0644]
tools/demo/Aquarium/obj/Debug/Key.g.cs [new file with mode: 0644]
tools/demo/Aquarium/obj/Debug/Window1.g.cs [new file with mode: 0644]
tools/dite/dite.c
tools/flounder/LMP.hs
tools/harness/machines/eth.py
tools/harness/tests/TimerTest.py [new file with mode: 0644]
tools/harness/tests/__init__.py
tools/scc/bootscc.sh
tools/scc/show.sh
tools/scc/watchall.sh [new file with mode: 0644]
tools/tracing/analyze_traces.py
usr/bcached/Hakefile [new file with mode: 0644]
usr/bcached/bcached.h [new file with mode: 0644]
usr/bcached/main.c [new file with mode: 0644]
usr/bcached/service.c [new file with mode: 0644]
usr/bench/bulk_bench/bulkbench.c
usr/bench/mem_alloc/Hakefile
usr/bench/mem_alloc/mem_alloc.c
usr/bench/xcorecap/xcorecapbench.c
usr/chips/dictionary.h
usr/chips/framework.c
usr/chips/hashtable.c
usr/chips/hashtable.h
usr/drivers/e1000/e1000n.c
usr/drivers/e1000/e1000n_hwinit.c
usr/drivers/eMAC/Hakefile [new file with mode: 0644]
usr/drivers/eMAC/eMAC_debug.c [new file with mode: 0644]
usr/drivers/eMAC/eMAC_debug.h [new file with mode: 0644]
usr/drivers/eMAC/eMAC_driver.c [new file with mode: 0644]
usr/drivers/eMAC/eMAC_driver.h [new file with mode: 0644]
usr/drivers/eMAC/eMAC_hwinit.c [new file with mode: 0644]
usr/drivers/eMAC/eMAC_spaces.h [new file with mode: 0644]
usr/drivers/lpc_timer/lpc_timer_debug.h
usr/drivers/lpc_timer/timer.c
usr/drivers/rtl8029/rtl8029.c
usr/drivers/rtl8029/rtl8029_debug.h
usr/examples/xmpl-perfmon/Hakefile [new file with mode: 0644]
usr/examples/xmpl-perfmon/menu.lst [new file with mode: 0644]
usr/examples/xmpl-perfmon/perfmon.c [new file with mode: 0644]
usr/fish/Hakefile
usr/fish/fish.c
usr/fish/ps.c
usr/fish/ps.h
usr/fsd/Hakefile [new file with mode: 0644]
usr/fsd/dictionary.h [new file with mode: 0644]
usr/fsd/fsd.h [new file with mode: 0644]
usr/fsd/hashtable.c [new file with mode: 0644]
usr/fsd/hashtable.h [new file with mode: 0644]
usr/fsd/main.c [new file with mode: 0644]
usr/fsd/multimap.h [new file with mode: 0644]
usr/fsd/ramfs.c [new file with mode: 0644]
usr/fsd/ramfs.h [new file with mode: 0644]
usr/fsd/service.c [new file with mode: 0644]
usr/init/mem_alloc.c
usr/init/spawn.c
usr/mem_serv/mem_serv.c
usr/mem_serv_dist/hybrid_support.c
usr/mem_serv_dist/mem_serv.c
usr/mem_serv_dist/mem_serv.h
usr/mem_serv_dist/steal.c
usr/mem_serv_dist/thc_support.c
usr/monitor/Hakefile
usr/monitor/arch/scc/boot.c
usr/monitor/arch/x86/boot.c
usr/monitor/domain.c
usr/monitor/inter.c
usr/monitor/main.c
usr/monitor/monitor.h
usr/monitor/monitor_rpc_server.c
usr/monitor/monitor_server.c
usr/monitor/queue.c
usr/monitor/ram_alloc.c
usr/monitor/spawn.c
usr/net-test/Hakefile [new file with mode: 0644]
usr/net-test/net-test.c [new file with mode: 0644]
usr/netd/Hakefile
usr/netd/idc_barrelfish.c
usr/netd/idc_barrelfish.h
usr/netd/lwipinit.c
usr/netd/main.c
usr/netd/netd.h
usr/netd/netd_debug.h
usr/netd/portalloc.c
usr/netfile/Hakefile
usr/netfile/netfile.c
usr/pci/pci.c
usr/pci/pcimain.c
usr/ramfsd/main.c
usr/ramfsd/ramfs.h
usr/ramfsd/service.c
usr/skb/eclipse_kernel/src/config.h
usr/skb/eclipse_kernel/src/handlers.c
usr/skb/skb_main.c
usr/slideshow/main.c
usr/spawnd/Hakefile
usr/spawnd/main.c
usr/spawnd/ps.c [new file with mode: 0644]
usr/spawnd/ps.h [new file with mode: 0644]
usr/spawnd/service.c
usr/startd/internal.h
usr/startd/main.c
usr/startd/spawn.c
usr/testdesc/Hakefile [new file with mode: 0644]
usr/testdesc/testdesc-child.c [new file with mode: 0644]
usr/testdesc/testdesc.c [new file with mode: 0644]
usr/testdesc/testdesc.h [new file with mode: 0644]
usr/tests/filetests/Hakefile
usr/tests/filetests/fread_test.c
usr/tests/filetests/fscanf_test.c [new file with mode: 0644]
usr/tests/memtest/Hakefile
usr/tests/memtest/mem_alloc.c [new file with mode: 0644]
usr/tests/memtest/mem_free.c [new file with mode: 0644]
usr/tests/memtest/memtest.c
usr/tests/net_openport_test/Hakefile [new file with mode: 0644]
usr/tests/net_openport_test/net_openport_test.c [new file with mode: 0644]
usr/tests/schedtest/deferred.c [new file with mode: 0644]
usr/tests/semaphores/Hakefile [new file with mode: 0644]
usr/tests/semaphores/semtest.c [new file with mode: 0644]
usr/tests/timer/timer.c
usr/vmkitmon/vmkitmon.c
usr/webserver/http_cache.c
usr/webserver/http_server.c
usr/webserver/main.c
usr/webserver/webserver_debug.h

diff --git a/AUTHORS b/AUTHORS
index 28044c3..f5e5bec 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -10,6 +10,7 @@ Ankush Gupta <guptaan@student.ethz.ch>
 Tim Harris <tharris@microsoft.com>
 Orion Hodson <ohodson@microsoft.com>
 Rebecca Isaacs <Rebecca.Isaacs@microsoft.com>
+Stefan Kästle <stefan.kaestle@inf.ethz.ch>
 Ihor Kuz <ihor.kuz@nicta.com.au>
 Ross McIlroy <rmcilroy@microsoft.com>
 Dominik Menzi <dmenzi@student.ethz.ch>
index 8b3ff4b..4fe269b 100644 (file)
@@ -317,3 +317,7 @@ cap Domain {
     /* Domain capability (opaque type, used by the monitors) */
     eq uint32 domainid;
 };
+
+cap PerfMon {
+       is_always_copy;
+};
index 132ee6f..4e884f0 100644 (file)
            "tulip",
            "x86_64_pagetable",
            "xapic",
-          "pci_hdr0_mem",
-          "rck",
-          "crb_sif"
+           "pci_hdr0_mem",
+           "rck",
+           "eMAC",
+           "crb_sif"
          ], arch <- allArchitectures
 ] ++
 
diff --git a/devices/eMAC.dev b/devices/eMAC.dev
new file mode 100644 (file)
index 0000000..9df2f17
--- /dev/null
@@ -0,0 +1,588 @@
+/*
+ * Copyright (c) 2008, ETH Zurich. All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+/*
+ * eMAC.dev
+ *
+ * DESCRIPTION: IP blocks from Xilinx.  Used as NIC in SCC board.
+ * 
+ * Numbers in comments refer to the 
+ * - 
+ * - sccKit140_UsersGuide_Part8.pdf  (By default, all numbers are from this doc)
+ *      https://wiki.netos.ethz.ch/BarrelFish/HWInfo?action=AttachFile&do=get&target=sccKit140_UsersGuide_Part8.pdf
+ * - Xlinx eMAC user guide.pdf (When referred as "Xilinx user guide")
+ *      https://wiki.netos.ethz.ch/BarrelFish/HWInfo?action=AttachFile&do=get&target=Xlinx+eMAC+user+guide.pdf
+ */
+
+device eMAC lsbfirst ( addr base ) "Xilinx IPblock" {
+/* Using MSB as it was used in rck.dev */
+/* FIXME: Either use absolute values 0x07000 or relative values 0x00000.
+        Find out which way is correct, and use it. */
+/* FIXME: Separate the definations in register and regtype */
+
+       space one_byte(idx) valuewise "Model specific register";
+
+    /******** IP Configuration registers *********/
+
+    /* Receiver Configuration(0) [31:0] R/W (see Xilinx eMAC user guide) */
+    /* Xilinx user guide: Table 4-2: Receiver Configuration Register (Word 0) */
+    regtype eMAC_receiver_conf_0 "Flow control Configuration register (0)" {
+        PAUSE_FRAME_ADDR_LOW    32      rw      "Pause Frame Ethernet MAC Address [31:0]. This address is used to match the Ethernet MAC against the destination address of any incoming flow control frames. It is also used by the flow control block as the source address for any outbound flow control frames. The address is ordered so the first byte transmitted/received is the lowest positioned byte in the register; for example, a MAC address of AA-BB-CC-DD-EE-FF is stored in address [47:0] as 0xFFEEDDCCBBAA.";
+    };
+
+
+    /* Receiver Configuration(1) [31:0] R/W (see Xilinx eMAC user guide) */
+    /* Xilinx user guide: Table 4-3: Receiver Configuration Register (Word 1) */
+    regtype eMAC_receiver_conf_1 "Flow control Configuration register (1)" {
+        PAUSE_FRAME_ADDR_LOW    16      rw      "Pause frame Ethernet MAC Address [47:32].";
+        _                       9      mbz     "Reserved";
+        LT_DIS                  1       rw      "Length/Type Check disable. When this bit is 1, it disables the Length/Type field check on the frame.";
+        HD                      1       rw      "Half-duplex mode. When this bit is 1, the receiver operates in half-duplex mode. When the bit is 0, the receiver operates in full-duplex mode.";
+        VLAN                    1       rw      "VLAN enable. When this bit is 1, the receiver accepts VLAN tagged frames. The maximum payload length increases by four bytes.";
+        RX                      1       rw      "Receive enable. When this bit is 1, the receiver block is enabled to operate. When the bit is 0, the receiver ignores activity on the physical interface receive port.";
+        FCS                     1       rw      "In-band FCS enable. When this bit is 1, the receiver passes the FCS field up to the client. When this bit is 0, the FCS field is not passed to the client. In either case, the FCS is verified on the frame.";
+        JUM                     1       rw      "Jumbo frame enable. When this bit is 1, the Ethernet MAC receiver accepts frames over the maximum length specified in IEEE Std 802.3-2002 specification. When this bit is 0, the receiver only accepts frames up to the specified maximum.";
+        RST                     1       rw      "Reset. When this bit is 1, the receiver is reset. The bit automatically reverts to 0. This reset also sets all of the receiver configuration registers to their default values.";
+    };
+
+
+    /* Transmiter configuration [31:0] R/W (see Xilinx eMAC user guide) */
+    /* Xilinx user guide: Table 4-4: Transmiter Configuration register */
+    regtype eMAC_transmiter_conf "eMAC Transmiter Configuration register" {
+        _          25      mbz     "Reserved";
+        IFG         1      rw      "IFG adjustment enable. When this bit is 1, the transmitter reads the value of CLIENTEMAC#TXIFGDELAY at the start of frame transmission and adjusts the IFG.";
+        HD          1      rw      "Half-duplex mode (applicable in 10/100 Mb/s mode only). When this bit is 1, the transmitter operates in half-duplex mode. When this bit is 0, the transmitter operates in full-duplex mode.";
+        VLAN        1      rw      "VLAN enable. When this bit is 1, the transmitter allows transmission of the VLAN tagged frames.";
+        TX          1      rw      "Transmit enable. When this bit is 1, the transmitter is enabled for operation.";
+        FCS         1      rw      "In-band FCS enable. When this bit is 1, the Ethernet MAC transmitter is ready for the FCS field from the client.";
+        JUM         1      rw      "Jumbo frame enable. When this bit is 1, the transmitter sends frames greater than the maximum length specified in IEEE Std 802.3-2002. When this bit is 0, it only sends frames less than the specified maximum length.";
+        RST         1      rw      "Reset. When this bit is 1, the transmitter is reset. The bit automatically reverts to 0. This reset also sets all of the transmitter configuration registers to their default values.";
+
+    };
+
+    /* Flow control configuration [31:0] R/W  (see Xilinx eMAC user guide) */
+    /* Xilinx user guide: Table 4-5: Flow control Configuration register */
+    regtype eMAC_flow_control_conf "Flow control Configuration register" {
+        _            29     mbz     "Reserved";
+        RX_FC_enable 1      rw      "Flow control enable (RX). When this bit is 1, the received flow control frames inhibit transmitter operation. When this bit is 0, the flow control frame is passed to the client.";
+        TX_FC_enable 1      rw      "Flow control enable (TX). When this bit is 1, the CLIENTEMAC#PAUSEREQ signal is asserted and a flow control frame is sent from the transmitter. When this bit is 0, the CLIENTEMAC#PAUSEREQ signal has no effect.";
+        _            1     mbz     "Reserved";
+    };
+
+    /* Ethernet MAC mode [31:0] R/W (see Xilinx eMAC user guide) */
+    /* Xilinx user guide: Table 4-6: Ethernet MAC Mode Configuration Register */
+    /* Attributes to Configure Fixed Mode for the Ethernet MAC */
+    regtype eMAC_ethernet_mac_conf "Ethernet MAC Mode Configuration register" {
+        _           24      mbz     "Reserved";
+        RX16         1      ro      "Receive 16-bit Client Interface enable. When this bit is 1, the receive data client interface is 16 bits wide. When this bit is 0, the receive data client interface is 8 bits wide. This bit is valid only when using 1000BASE-X PCS/PMA mode.";
+        TX16         1      ro      "Transmit 16-bit Client Interface enable. When this bit is 1, the transmit data client interface is 16 bits wide. When this bit is 0, the transmit data client interface is 8 bits wide. This bit is valid only when using 1000BASE-X PCS/PMA mode.";
+        HOST         1      ro      "Host Interface enable. When this bit is 1, the host interface is enabled. When this bit is 0, the host interface is disabled.";
+        GPCS         1      ro      "1000BASE-X mode enable. When this bit is 1, the Ethernet MAC is configured in 1000BASE-X mode.";
+        SGMII        1      ro      "SGMII mode enable. When this bit is 1, the Ethernet MAC is configured in SGMII mode.";
+        RGMII        1      ro      "RGMII mode enable. When this bit is 1, the Ethernet MAC is configured in RGMII mode.";
+        LINK_SPEED   2      rw      "Speed selection. The speed of the Ethernet MAC is defined by the following values: 10 = 1000 Mb/s, 01 = 100 Mb/s, 00 = 10 Mb/s, 11 = N/A";
+    };
+
+
+    /* Address Filter Mode [31:0] R/W (see Xilinx eMAC user guide) */
+    /* Xilinx user guide: Table 4-13: Address Filter Mode */
+    regtype eMAC_address_filter_mode "Address filter mode Configuration register" {
+        _           31      mbz     "Reserved";
+        PM          1      rw      "Promiscuous Mode enable. When this bit is 1, the Address Filter block is disabled. When this bit is 0, the Address Filter block is enabled.";
+    };
+
+
+    /*******  eMAC status registers ******/
+
+    regtype RX_frame_dropped "RX Frame Dropped Channel" {
+        status   1  rw        "Set when frame dropped due to RX buffer overflow in DDR3";
+        _       31  mbz       "Unused";
+    };
+
+    regtype TX_FIFO_buff_full "TX FIFO buffer full" {
+        status   1  ro        "Set in case of an overflow of TX fifo buffer in eMAC IP block";
+        _       31  mbz       "Unused";
+    };
+
+    regtype RX_FIFO_buff_full "RX FIFO buffer full" {
+        status   1  ro        "Set in case of an overflow of RX fifo buffer in eMAC IP block";
+        _       31  mbz       "Unused";
+    };
+    
+     regtype TX_EMAC_Not_Ready "TX EMAC not ready" {
+        status   1  ro        "eMAC does not accept frames";
+        _       31  mbz       "Unused";
+    };
+    
+     regtype RX_MAC_Addr_Err "RX MAC address error" {
+        status   1  ro        "MAC address not found in table";
+        _       31  mbz       "Unused";
+    };
+    
+    regtype RX_MAC_Lower "RX MAC address lower part" {
+        mac_low 32  ro        "Lower 32 bits of MAC address that has not been found";
+    };
+    
+    regtype RX_MAC_Higher "RX MAC address higher part" {
+        mac_high 16     ro      "Upper 16 bits of MAC address that has not been found";
+        _        16     mbz     "Unused"; // FIXME: Should these 16 bits be commented? as they were not mentioned in the doc
+    };
+
+
+
+    /***** eMAC General Configuration Registers ********/
+
+    regtype eMAC_MAC_base_addr_upper "eMAC config MAC base address (high)" {
+        mac_upper    16     rw      "Upper 16 bits of base MAC address";
+        _            16     mbz     "Unused";
+    };
+
+    regtype eMAC_MAC_base_addr_lower "eMAC config MAC base address (low)" {
+        mac_lower   32      rw      "Lower 32 bits of base MAC address";
+    };
+
+    regtype eMAC_start_IP_SCC_network "eMAC config Start IP Address of SCC network" {
+        ip          32      rw      "IP Address for SCC Core 0. IPs for other cores are assigned in order";
+    };
+
+    regtype eMAC_host_IP_addr "eMAC config Host IP Address" {
+        ip          32      rw      "IP Address of Host computer where /shared is mounted";
+    };
+
+    regtype eMAC_host_GW_addr "eMAC config Host gateway Address" {
+        ip          32      rw      "Gateway of Host computer";
+  };
+
+
+    /****** Registers for "RX Control Registers" ******/
+    regtype RX_Buffer_start_addr "RX control RX Buffer Start Address" {
+        ADDR    29  rw      "Upper 29 bit of physical start address [33:5] of memory buffer. Lower 5 bits are always 0 because access granularity to buffer will be always 32 bytes – one cache-line.";
+        _       3   mbz     "Unused";
+    };
+
+    regtype RX_Buffer_read_index "RX control RX Buffer Read Index" {
+        rid 16  rw      "Read index of RX buffer Points to 32 byte entry in the buffer.";
+        _   16  mbz     "Unused";
+    };
+
+    regtype RX_Buffer_write_index "RX control RX Buffer Write Index" {
+        wid 16  ro      "Write index of RX buffer Points to 32 byte entry in the buffer.";
+        _   16  mbz     "Unused";
+    };
+
+    regtype RX_Buffer_last_index "RX control RX Buffer Last Index" {
+        lid 16  rw      "Last valid index in buffer. .Buffer size = last index * 32 bytes";
+        _   16  mbz     "Unused";
+    };
+/*
+    regtype RX_Buffer_reserved "RX control reserved" {
+        _   32  mbz     "Unused";
+    };
+*/
+
+    regtype RX_routing "RX control RX routing related" {
+        broute  8   rw      "Route to the tile where the MC for this buffer is located";
+        bdest   3   rw      "Defines the port at which the MC is connected";
+        _       5   mbz     "Unused";
+        iroute  8   rw      "Route to the tile where the core for this buffer is located";
+        idest   3   rw      "Selects core 0 or core 1 in the tile";
+        _       5   mbz     "Unused";
+    };
+
+
+    regtype RX_net_port_MAC_high "RX Network Port MAC Address (high)" {
+        mac_hi  16      rw      "Higher 16 bits of MAC addresses";
+        _       16      mbz     "Unused";
+    };
+
+    regtype RX_net_port_MAC_low "RX Network Port MAC Address (low)" {
+        mac_lo     32      rw      "Lower 32 bits of MAC addresses";
+    };
+
+    regtype RX_net_port_enable "RX Network Port Enable" {
+        enable   1      rw      "1 – Enabled, 0 – Disabled";
+        _       31      mbz     "Unused";
+    };
+    
+    
+    
+    /****** register types for TX control registers *******/
+
+
+    regtype TX_Buffer_start_addr "TX control TX Buffer Start Address" {
+        ADDR    29  rw      "Upper 29 bit of physical start address [33:5] of memory buffer. Lower 5 bits are always 0 because access granularity to buffer will be always 32 bytes – one cache-line.";
+        _       3   mbz     "Unused";
+    };
+
+
+    regtype TX_Buffer_read_index "TX control TX Buffer Read Index" {
+        rid 16  ro      "Read index of TX buffer Points to 32 byte entry in the buffer.";
+        _   16  mbz     "Unused";
+    };
+
+
+    regtype TX_Buffer_write_index "TX control TX Buffer Write Index" {
+        wid 16  rw      "Write index of TX buffer Points to 32 byte entry in the buffer.";
+        _   16  mbz     "Unused";
+    };
+
+    regtype TX_Buffer_last_index "TX control TX Buffer Last Index" {
+        lid 16  rw      "Last valid index in buffer. .Buffer size = last index * 32 bytes";
+        _   16  mbz     "Unused";
+    };
+
+
+    regtype TX_routing "TX control RX routing related" {
+        broute  8   rw      "Route to the tile where the MC for this buffer is located";
+        bdest   3   rw      "Defines the port at which the MC is connected";
+        _       21   mbz     "Unused";
+    };
+
+
+    regtype TX_net_port_enable "TX Network Port Enable" {
+        enable   1      rw      "1 – Enabled, 0 – Disabled";
+        _       31      mbz     "Unused";
+    };
+    
+    
+
+    /* 8.3.5.1 eMAC#0 IP Configuration Registers (03200 to 03390) */
+    register eMAC0_receiver_conf_0       addr(base, 0x03200) type(eMAC_receiver_conf_0);
+    register eMAC0_receiver_conf_1       addr(base, 0x03240) type(eMAC_receiver_conf_1);
+    register eMAC0_transmiter_conf       addr(base, 0x03280) type(eMAC_transmiter_conf);
+    register eMAC0_flow_control_conf     addr(base, 0x032C0) type(eMAC_flow_control_conf);
+    register eMAC0_ethernet_mac_conf     addr(base, 0x03300) type(eMAC_ethernet_mac_conf);
+    register eMAC0_address_filter_mode   addr(base, 0x03900) type(eMAC_address_filter_mode);
+
+
+    /* 8.3.5.3 eMAC#1 IP Configuration Register (04200 to 04390) */
+    register eMAC1_receiver_conf_0       addr(base, 0x04200) type(eMAC_receiver_conf_0);
+    register eMAC1_receiver_conf_1       addr(base, 0x04240) type(eMAC_receiver_conf_1);
+    register eMAC1_transmiter_conf       addr(base, 0x04280) type(eMAC_transmiter_conf);
+    register eMAC1_flow_control_conf     addr(base, 0x042C0) type(eMAC_flow_control_conf);
+    register eMAC1_ethernet_mac_conf     addr(base, 0x04300) type(eMAC_ethernet_mac_conf);
+    register eMAC1_address_filter_mode   addr(base, 0x04900) type(eMAC_address_filter_mode);
+
+
+    /* 8.3.5.5 eMAC#2 IP Configuration Registers (05200 to 05390) */
+    register eMAC2_receiver_conf_0       addr(base, 0x05200) type(eMAC_receiver_conf_0);
+    register eMAC2_receiver_conf_1       addr(base, 0x05240) type(eMAC_receiver_conf_1);
+    register eMAC2_transmiter_conf       addr(base, 0x05280) type(eMAC_transmiter_conf);
+    register eMAC2_flow_control_conf     addr(base, 0x052C0) type(eMAC_flow_control_conf);
+    register eMAC2_ethernet_mac_conf     addr(base, 0x05300) type(eMAC_ethernet_mac_conf);
+    register eMAC2_address_filter_mode   addr(base, 0x05900) type(eMAC_address_filter_mode);
+
+
+    /* 8.3.5.7 eMAC#3 IP Configuration Registers (06200 to 06390) */
+    register eMAC3_receiver_conf_0       addr(base, 0x06200) type(eMAC_receiver_conf_0);
+    register eMAC3_receiver_conf_1       addr(base, 0x06240) type(eMAC_receiver_conf_1);
+    register eMAC3_transmiter_conf       addr(base, 0x06280) type(eMAC_transmiter_conf);
+    register eMAC3_flow_control_conf     addr(base, 0x062C0) type(eMAC_flow_control_conf);
+    register eMAC3_ethernet_mac_conf     addr(base, 0x06300) type(eMAC_ethernet_mac_conf);
+    register eMAC3_address_filter_mode   addr(base, 0x06900) type(eMAC_address_filter_mode);
+
+
+    /* 8.3.6.1 eMAC#0 status registers (0x07000 to 0x07044) */
+//    register eMAC0_RX_frame_dropped addr(base, 0x00000) type(RX_frame_dropped);
+//    register eMAC0_RX_frame_dropped one_byte(0x00000) type(RX_frame_dropped);
+    regarray eMAC0_RX_frame_dropped  one_byte(  0x07000)[47] type(RX_frame_dropped);
+    register eMAC0_TX_FIFO_BUFF_FULL addr(base, 0x07030) type(TX_FIFO_buff_full);
+    register eMAC0_RX_FIFO_BUFF_FULL addr(base, 0x07034) type(RX_FIFO_buff_full);
+    register eMAC0_TX_EMAC_NOT_READY addr(base, 0x07038) type(TX_EMAC_Not_Ready);
+    register eMAC0_RX_MAC_ADDR_ERR   addr(base, 0x0703C) type(RX_MAC_Addr_Err);
+    register eMAC0_RX_MAC_LOWER      addr(base, 0x07040) type(RX_MAC_Lower);
+    register eMAC0_RX_MAC_HIGHER     addr(base, 0x07044) type(RX_MAC_Higher);
+    
+    /* 8.3.6.2 eMAC#1 status registers (0x07100 to 0x07144) */
+    regarray eMAC1_RX_frame_dropped  one_byte(  0x07100)[47] type(RX_frame_dropped);
+    register eMAC1_TX_FIFO_BUFF_FULL addr(base, 0x07130) type(TX_FIFO_buff_full);
+    register eMAC1_RX_FIFO_BUFF_FULL addr(base, 0x07134) type(RX_FIFO_buff_full);
+    register eMAC1_TX_EMAC_NOT_READY addr(base, 0x07138) type(TX_EMAC_Not_Ready);
+    register eMAC1_RX_MAC_ADDR_ERR   addr(base, 0x0713C) type(RX_MAC_Addr_Err);
+    register eMAC1_RX_MAC_LOWER      addr(base, 0x07140) type(RX_MAC_Lower);
+    register eMAC1_RX_MAC_HIGHER     addr(base, 0x07144) type(RX_MAC_Higher);
+
+    /* 8.3.6.3 eMAC#2 status registers (0x07200 to 0x07244) */
+    regarray eMAC2_RX_frame_dropped  one_byte(  0x07200)[47] type(RX_frame_dropped);
+    register eMAC2_TX_FIFO_BUFF_FULL addr(base, 0x07230) type(TX_FIFO_buff_full);
+    register eMAC2_RX_FIFO_BUFF_FULL addr(base, 0x07234) type(RX_FIFO_buff_full);
+    register eMAC2_TX_EMAC_NOT_READY addr(base, 0x07238) type(TX_EMAC_Not_Ready);
+    register eMAC2_RX_MAC_ADDR_ERR   addr(base, 0x0723C) type(RX_MAC_Addr_Err);
+    register eMAC2_RX_MAC_LOWER      addr(base, 0x07240) type(RX_MAC_Lower);
+    register eMAC2_RX_MAC_HIGHER     addr(base, 0x07244) type(RX_MAC_Higher);
+
+    /* 8.3.6.4 eMAC#3 status registers (0x07300 to 0x07344) */
+    regarray eMAC3_RX_frame_dropped  one_byte(  0x07300)[47] type(RX_frame_dropped);
+    register eMAC3_TX_FIFO_BUFF_FULL addr(base, 0x07330) type(TX_FIFO_buff_full);
+    register eMAC3_RX_FIFO_BUFF_FULL addr(base, 0x07334) type(RX_FIFO_buff_full);
+    register eMAC3_TX_EMAC_NOT_READY addr(base, 0x07338) type(TX_EMAC_Not_Ready);
+    register eMAC3_RX_MAC_ADDR_ERR   addr(base, 0x0733C) type(RX_MAC_Addr_Err);
+    register eMAC3_RX_MAC_LOWER      addr(base, 0x07340) type(RX_MAC_Lower);
+    register eMAC3_RX_MAC_HIGHER     addr(base, 0x07344) type(RX_MAC_Higher);
+
+    /* 8.3.6.5 eMAC General Configuration Registers (0x07e00 to 0x07e10) */
+    register eMAC_MAC_base_addr_upper_reg addr(base, 0x07e00) type(eMAC_MAC_base_addr_upper);
+    register eMAC_MAC_base_addr_lower_reg addr(base, 0x07e04) type(eMAC_MAC_base_addr_lower);
+    register eMAC_start_IP_SCC_network_reg addr(base, 0x07e08) type(eMAC_start_IP_SCC_network);
+    register eMAC_host_IP_addr_reg addr(base, 0x07e0c) type(eMAC_host_IP_addr);
+    register eMAC_host_GW_addr_reg addr(base, 0x07e10) type(eMAC_host_GW_addr);
+
+
+    /* 8.3.6.6 eMAC#0 RX Control Registers (09000 to 098BC) */
+    regarray eMAC0_RX_Buffer_start_addr     addr(base, 0x09000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC0_RX_Buffer_read_index     addr(base, 0x09100)[48] type(RX_Buffer_read_index);
+    regarray eMAC0_RX_Buffer_write_index    addr(base, 0x09200)[48] type(RX_Buffer_write_index);
+    regarray eMAC0_RX_Buffer_last_index     addr(base, 0x09300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC0_RX_Buffer_reserved     addr(base, 0x09400)[48] type(RX_Buffer_reserved);
+    regarray eMAC0_RX_routing               addr(base, 0x09500)[48] type(RX_routing);
+    regarray eMAC0_RX_net_port_MAC_high     addr(base, 0x09600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC0_RX_net_port_MAC_low      addr(base, 0x09700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC0_RX_net_port_enable       addr(base, 0x09800)[48] type(RX_net_port_enable);
+    
+
+    /* 8.3.6.7  eMAC#0 TX Control Registers (09900 to 09EBC) */
+    regarray eMAC0_TX_Buffer_start_addr  addr(base, 0x09900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC0_TX_Buffer_read_index  addr(base, 0x09A00)[48] type(TX_Buffer_read_index);
+    regarray eMAC0_TX_Buffer_write_index addr(base, 0x09B00)[48] type(TX_Buffer_write_index);
+    regarray eMAC0_TX_Buffer_last_index  addr(base, 0x09C00)[48] type(TX_Buffer_last_index);
+    regarray eMAC0_TX_routing            addr(base, 0x09D00)[48] type(TX_routing);
+    regarray eMAC0_TX_net_port_enable    addr(base, 0x09E00)[48] type(TX_net_port_enable);
+
+    /* 8.3.6.8 eMAC#1 RX Control Registers (0A000 to 0A8BC) */
+    regarray eMAC1_RX_Buffer_start_addr     addr(base, 0x0A000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC1_RX_Buffer_read_index     addr(base, 0x0A100)[48] type(RX_Buffer_read_index);
+    regarray eMAC1_RX_Buffer_write_index    addr(base, 0x0A200)[48] type(RX_Buffer_write_index);
+    regarray eMAC1_RX_Buffer_last_index     addr(base, 0x0A300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC1_RX_Buffer_reserved     addr(base, 0x0A400)[48] type(RX_Buffer_reserved);
+    regarray eMAC1_RX_routing               addr(base, 0x0A500)[48] type(RX_routing);
+    regarray eMAC1_RX_net_port_MAC_high     addr(base, 0x0A600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC1_RX_net_port_MAC_low      addr(base, 0x0A700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC1_RX_net_port_enable       addr(base, 0x0A800)[48] type(RX_net_port_enable);
+
+
+    /* 8.3.6.9  eMAC#1 TX Control Registers (0A900 to 0AEBC) */
+    regarray eMAC1_TX_Buffer_start_addr  addr(base, 0x0A900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC1_TX_Buffer_read_index  addr(base, 0x0AA00)[48] type(TX_Buffer_read_index);
+    regarray eMAC1_TX_Buffer_write_index addr(base, 0x0AB00)[48] type(TX_Buffer_write_index);
+    regarray eMAC1_TX_Buffer_last_index  addr(base, 0x0AC00)[48] type(TX_Buffer_last_index);
+    regarray eMAC1_TX_routing            addr(base, 0x0AD00)[48] type(TX_routing);
+    regarray eMAC1_TX_net_port_enable    addr(base, 0x0AE00)[48] type(TX_net_port_enable);
+
+    /* 8.3.6.10 eMAC#2 RX Control Registers (0B000 to 0B8BC) */
+    regarray eMAC2_RX_Buffer_start_addr     addr(base, 0x0B000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC2_RX_Buffer_read_index     addr(base, 0x0B100)[48] type(RX_Buffer_read_index);
+    regarray eMAC2_RX_Buffer_write_index    addr(base, 0x0B200)[48] type(RX_Buffer_write_index);
+    regarray eMAC2_RX_Buffer_last_index     addr(base, 0x0B300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC2_RX_Buffer_reserved     addr(base, 0x0B400)[48] type(RX_Buffer_reserved);
+    regarray eMAC2_RX_routing               addr(base, 0x0B500)[48] type(RX_routing);
+    regarray eMAC2_RX_net_port_MAC_high     addr(base, 0x0B600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC2_RX_net_port_MAC_low      addr(base, 0x0B700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC2_RX_net_port_enable       addr(base, 0x0B800)[48] type(RX_net_port_enable);
+
+
+    /* 8.3.6.11  eMAC#2 TX Control Registers (0B900 to 0BEBC) */
+    regarray eMAC2_TX_Buffer_start_addr  addr(base, 0x0B900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC2_TX_Buffer_read_index  addr(base, 0x0BA00)[48] type(TX_Buffer_read_index);
+    regarray eMAC2_TX_Buffer_write_index addr(base, 0x0BB00)[48] type(TX_Buffer_write_index);
+    regarray eMAC2_TX_Buffer_last_index  addr(base, 0x0BC00)[48] type(TX_Buffer_last_index);
+    regarray eMAC2_TX_routing            addr(base, 0x0BD00)[48] type(TX_routing);
+    regarray eMAC2_TX_net_port_enable    addr(base, 0x0BE00)[48] type(TX_net_port_enable);
+
+    /* 8.3.6.12 eMAC#3 RX Control Registers (0C000 to 0C8BC) */
+    regarray eMAC3_RX_Buffer_start_addr     addr(base, 0x0C000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC3_RX_Buffer_read_index     addr(base, 0x0C100)[48] type(RX_Buffer_read_index);
+    regarray eMAC3_RX_Buffer_write_index    addr(base, 0x0C200)[48] type(RX_Buffer_write_index);
+    regarray eMAC3_RX_Buffer_last_index     addr(base, 0x0C300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC3_RX_Buffer_reserved     addr(base, 0x0C400)[48] type(RX_Buffer_reserved);
+    regarray eMAC3_RX_routing               addr(base, 0x0C500)[48] type(RX_routing);
+    regarray eMAC3_RX_net_port_MAC_high     addr(base, 0x0C600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC3_RX_net_port_MAC_low      addr(base, 0x0C700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC3_RX_net_port_enable       addr(base, 0x0C800)[48] type(RX_net_port_enable);
+
+
+    /* 8.3.6.13  eMAC#3 TX Control Registers (0C900 to 0CEBC) */
+    regarray eMAC3_TX_Buffer_start_addr  addr(base, 0x0C900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC3_TX_Buffer_read_index  addr(base, 0x0CA00)[48] type(TX_Buffer_read_index);
+    regarray eMAC3_TX_Buffer_write_index addr(base, 0x0CB00)[48] type(TX_Buffer_write_index);
+    regarray eMAC3_TX_Buffer_last_index  addr(base, 0x0CC00)[48] type(TX_Buffer_last_index);
+    regarray eMAC3_TX_routing            addr(base, 0x0CD00)[48] type(TX_routing);
+    regarray eMAC3_TX_net_port_enable    addr(base, 0x0CE00)[48] type(TX_net_port_enable);
+
+    // regtype irq_status "Interrupt Status" {
+    //                _          5          ro      "Reserved";
+    // };
+
+    regarray PIC_irq_status addr(base, 0xd000)[48] type(uint64);
+    regarray PIC_irq_mask   addr(base, 0xd200)[48] type(uint64);
+    regarray PIC_irq_reset  addr(base, 0xd400)[48] type(uint64);
+    regarray PIC_ipi_request    addr(base, 0xd600)[48] type(uint64);
+
+/*
+    regarray PIC_irq_status    addr(base, 0xd000)[96] type(uint32);
+    regarray PIC_irq_mask      addr(base, 0xd200)[96] type(uint32);
+    regarray PIC_irq_reset     addr(base, 0xd400)[96] type(uint32);
+    regarray PIC_ipi_request   addr(base, 0xd600)[96] type(uint32);
+*/
+    regarray PIC_irq_config    addr(base, 0xd800)[48] type(uint32);
+
+    register PIC_irq_request_mcpc addr(base, 0xd900) type(uint64);
+
+}; /* end device: eMAC */
+
+
+/*
+// 8.3.6.1 eMAC#0 status registers (0x07000 to 0x07044)
+
+    regarray eMAC0_RX_frame_dropped  one_byte(  0x00000)[47] type(RX_frame_dropped);
+    register eMAC0_TX_FIFO_BUFF_FULL addr(base, 0x00030) type(TX_FIFO_buff_full);
+    register eMAC0_RX_FIFO_BUFF_FULL addr(base, 0x00034) type(RX_FIFO_buff_full);
+    register eMAC0_TX_EMAC_NOT_READY addr(base, 0x00038) type(TX_EMAC_Not_Ready);
+    register eMAC0_RX_MAC_ADDR_ERR   addr(base, 0x0003C) type(RX_MAC_Addr_Err);
+    register eMAC0_RX_MAC_LOWER      addr(base, 0x00040) type(RX_MAC_Lower);
+    register eMAC0_RX_MAC_HIGHER     addr(base, 0x00044) type(RX_MAC_Higher);
+
+
+// 8.3.6.2 eMAC#1 status registers (0x07100 to 0x07144)
+
+    regarray eMAC1_RX_frame_dropped  one_byte(  0x00100)[47] type(RX_frame_dropped);
+    register eMAC1_TX_FIFO_BUFF_FULL addr(base, 0x00130) type(TX_FIFO_buff_full);
+    register eMAC1_RX_FIFO_BUFF_FULL addr(base, 0x00134) type(RX_FIFO_buff_full);
+    register eMAC1_TX_EMAC_NOT_READY addr(base, 0x00138) type(TX_EMAC_Not_Ready);
+    register eMAC1_RX_MAC_ADDR_ERR   addr(base, 0x0013C) type(RX_MAC_Addr_Err);
+    register eMAC1_RX_MAC_LOWER      addr(base, 0x00140) type(RX_MAC_Lower);
+    register eMAC1_RX_MAC_HIGHER     addr(base, 0x00144) type(RX_MAC_Higher);
+
+
+// 8.3.6.3 eMAC#2 status registers (0x07200 to 0x07244)
+    regarray eMAC2_RX_frame_dropped  one_byte(  0x00200)[47] type(RX_frame_dropped);
+    register eMAC2_TX_FIFO_BUFF_FULL addr(base, 0x00230) type(TX_FIFO_buff_full);
+    register eMAC2_RX_FIFO_BUFF_FULL addr(base, 0x00234) type(RX_FIFO_buff_full);
+    register eMAC2_TX_EMAC_NOT_READY addr(base, 0x00238) type(TX_EMAC_Not_Ready);
+    register eMAC2_RX_MAC_ADDR_ERR   addr(base, 0x0023C) type(RX_MAC_Addr_Err);
+    register eMAC2_RX_MAC_LOWER      addr(base, 0x00240) type(RX_MAC_Lower);
+    register eMAC2_RX_MAC_HIGHER     addr(base, 0x00244) type(RX_MAC_Higher);
+
+
+// 8.3.6.4 eMAC#3 status registers (0x07300 to 0x07344)
+
+    regarray eMAC3_RX_frame_dropped  one_byte(  0x00300)[47] type(RX_frame_dropped);
+    register eMAC3_TX_FIFO_BUFF_FULL addr(base, 0x00330) type(TX_FIFO_buff_full);
+    register eMAC3_RX_FIFO_BUFF_FULL addr(base, 0x00334) type(RX_FIFO_buff_full);
+    register eMAC3_TX_EMAC_NOT_READY addr(base, 0x00338) type(TX_EMAC_Not_Ready);
+    register eMAC3_RX_MAC_ADDR_ERR   addr(base, 0x0033C) type(RX_MAC_Addr_Err);
+    register eMAC3_RX_MAC_LOWER      addr(base, 0x00340) type(RX_MAC_Lower);
+    register eMAC3_RX_MAC_HIGHER     addr(base, 0x00344) type(RX_MAC_Higher);
+
+
+// 8.3.6.5 eMAC General Configuration Registers (0x07e00 to 0x07e10)
+
+    register eMAC_MAC_base_addr_upper rw addr(base, 0x00e00) "eMAC config MAC base address (high)" {
+        _            16     mbz     "Unused";
+        mac_upper    16     rw      "Upper 16 bits of base MAC address";
+    };
+
+
+    register eMAC_MAC_base_addr_lower addr(base, 0x00e04) "eMAC config MAC base address (low)" {
+        mac_lower   32      rw      "Lower 32 bits of base MAC address";
+    };
+
+    register eMAC_start_IP_SCC_network addr(base, 0x00e08) "eMAC config Start IP Address of SCC network" {
+        ip          32      rw      "IP Address for SCC Core 0. IPs for other cores are assigned in order";
+    };
+
+    register eMAC_host_IP_addr addr(base, 0x00e0c) "eMAC config Host IP Address" {
+        ip          32      rw      "IP Address of Host computer where /shared is mounted";
+    };
+
+    register eMAC_host_GW_addr addr(base, 0x00e10) "eMAC config Host gateway Address" {
+        ip          32      rw      "Gateway of Host computer";
+  };
+
+
+// 8.3.6.6 eMAC#0 RX Control Registers (09000 to 098BC)
+    regarray eMAC0_RX_Buffer_start_addr     addr(base, 0x02000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC0_RX_Buffer_read_index     addr(base, 0x02100)[48] type(RX_Buffer_read_index);
+    regarray eMAC0_RX_Buffer_write_index    addr(base, 0x02200)[48] type(RX_Buffer_write_index);
+    regarray eMAC0_RX_Buffer_last_index     addr(base, 0x02300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC0_RX_Buffer_reserved     addr(base, 0x02400)[48] type(RX_Buffer_reserved);
+    regarray eMAC0_RX_routing               addr(base, 0x02500)[48] type(RX_routing);
+    regarray eMAC0_RX_net_port_MAC_high     addr(base, 0x02600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC0_RX_net_port_MAC_low      addr(base, 0x02700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC0_RX_net_port_enable       addr(base, 0x02800)[48] type(RX_net_port_enable);
+
+
+// 8.3.6.7  eMAC#0 TX Control Registers (09900 to 09EBC)
+    regarray eMAC0_TX_Buffer_start_addr  addr(base, 0x02900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC0_TX_Buffer_read_index  addr(base, 0x02A00)[48] type(TX_Buffer_read_index);
+    regarray eMAC0_TX_Buffer_write_index addr(base, 0x02B00)[48] type(TX_Buffer_write_index);
+    regarray eMAC0_TX_Buffer_last_index  addr(base, 0x02C00)[48] type(TX_Buffer_last_index);
+    regarray eMAC0_TX_routing            addr(base, 0x02D00)[48] type(TX_routing);
+    regarray eMAC0_TX_net_port_enable    addr(base, 0x02E00)[48] type(TX_net_port_enable);
+
+
+// 8.3.6.8 eMAC#1 RX Control Registers (0A000 to 0A8BC)
+    regarray eMAC1_RX_Buffer_start_addr     addr(base, 0x03000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC1_RX_Buffer_read_index     addr(base, 0x03100)[48] type(RX_Buffer_read_index);
+    regarray eMAC1_RX_Buffer_write_index    addr(base, 0x03200)[48] type(RX_Buffer_write_index);
+    regarray eMAC1_RX_Buffer_last_index     addr(base, 0x03300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC1_RX_Buffer_reserved     addr(base, 0x03400)[48] type(RX_Buffer_reserved);
+    regarray eMAC1_RX_routing               addr(base, 0x03500)[48] type(RX_routing);
+    regarray eMAC1_RX_net_port_MAC_high     addr(base, 0x03600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC1_RX_net_port_MAC_low      addr(base, 0x03700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC1_RX_net_port_enable       addr(base, 0x03800)[48] type(RX_net_port_enable);
+
+
+// 8.3.6.9  eMAC#1 TX Control Registers (0A900 to 0AEBC)
+    regarray eMAC1_TX_Buffer_start_addr  addr(base, 0x03900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC1_TX_Buffer_read_index  addr(base, 0x03A00)[48] type(TX_Buffer_read_index);
+    regarray eMAC1_TX_Buffer_write_index addr(base, 0x03B00)[48] type(TX_Buffer_write_index);
+    regarray eMAC1_TX_Buffer_last_index  addr(base, 0x03C00)[48] type(TX_Buffer_last_index);
+    regarray eMAC1_TX_routing            addr(base, 0x03D00)[48] type(TX_routing);
+    regarray eMAC1_TX_net_port_enable    addr(base, 0x03E00)[48] type(TX_net_port_enable);
+
+// 8.3.6.10 eMAC#2 RX Control Registers (0B000 to 0B8BC)
+    regarray eMAC2_RX_Buffer_start_addr     addr(base, 0x04000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC2_RX_Buffer_read_index     addr(base, 0x04100)[48] type(RX_Buffer_read_index);
+    regarray eMAC2_RX_Buffer_write_index    addr(base, 0x04200)[48] type(RX_Buffer_write_index);
+    regarray eMAC2_RX_Buffer_last_index     addr(base, 0x04300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC2_RX_Buffer_reserved     addr(base, 0x04400)[48] type(RX_Buffer_reserved);
+    regarray eMAC2_RX_routing               addr(base, 0x04500)[48] type(RX_routing);
+    regarray eMAC2_RX_net_port_MAC_high     addr(base, 0x04600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC2_RX_net_port_MAC_low      addr(base, 0x04700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC2_RX_net_port_enable       addr(base, 0x04800)[48] type(RX_net_port_enable);
+
+
+// 8.3.6.11  eMAC#2 TX Control Registers (0B900 to 0BEBC)
+    regarray eMAC2_TX_Buffer_start_addr  addr(base, 0x04900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC2_TX_Buffer_read_index  addr(base, 0x04A00)[48] type(TX_Buffer_read_index);
+    regarray eMAC2_TX_Buffer_write_index addr(base, 0x04B00)[48] type(TX_Buffer_write_index);
+    regarray eMAC2_TX_Buffer_last_index  addr(base, 0x04C00)[48] type(TX_Buffer_last_index);
+    regarray eMAC2_TX_routing            addr(base, 0x04D00)[48] type(TX_routing);
+    regarray eMAC2_TX_net_port_enable    addr(base, 0x04E00)[48] type(TX_net_port_enable);
+
+// 8.3.6.12 eMAC#3 RX Control Registers (0C000 to 0C8BC)
+    regarray eMAC3_RX_Buffer_start_addr     addr(base, 0x05000)[48] type(RX_Buffer_start_addr);
+    regarray eMAC3_RX_Buffer_read_index     addr(base, 0x05100)[48] type(RX_Buffer_read_index);
+    regarray eMAC3_RX_Buffer_write_index    addr(base, 0x05200)[48] type(RX_Buffer_write_index);
+    regarray eMAC3_RX_Buffer_last_index     addr(base, 0x05300)[48] type(RX_Buffer_last_index);
+//    regarray eMAC3_RX_Buffer_reserved     addr(base, 0x05400)[48] type(RX_Buffer_reserved);
+    regarray eMAC3_RX_routing               addr(base, 0x05500)[48] type(RX_routing);
+    regarray eMAC3_RX_net_port_MAC_high     addr(base, 0x05600)[48] type(RX_net_port_MAC_high);
+    regarray eMAC3_RX_net_port_MAC_low      addr(base, 0x05700)[48] type(RX_net_port_MAC_low);
+    regarray eMAC3_RX_net_port_enable       addr(base, 0x05800)[48] type(RX_net_port_enable);
+
+
+// 8.3.6.13  eMAC#3 TX Control Registers (0C900 to 0CEBC)
+    regarray eMAC3_TX_Buffer_start_addr  addr(base, 0x05900)[48] type(TX_Buffer_start_addr);
+    regarray eMAC3_TX_Buffer_read_index  addr(base, 0x05A00)[48] type(TX_Buffer_read_index);
+    regarray eMAC3_TX_Buffer_write_index addr(base, 0x05B00)[48] type(TX_Buffer_write_index);
+    regarray eMAC3_TX_Buffer_last_index  addr(base, 0x05C00)[48] type(TX_Buffer_last_index);
+    regarray eMAC3_TX_routing            addr(base, 0x05D00)[48] type(TX_routing);
+    regarray eMAC3_TX_net_port_enable    addr(base, 0x05E00)[48] type(TX_net_port_enable);
+
+*/
index ae6f3c0..37abd77 100644 (file)
@@ -94,15 +94,16 @@ device xapic lsbfirst ( addr base ) "Local APIC" {
 
   regtype lvt_mon "LVT monitor" {
     vector      8 "Vector";
-    dlv_mode    4 type(vdm) "Delivery mode";
+    msgType     3;
     _           1;
     status      1 "Delivery status";
     _           3;
-    mask        1 type(int_mask) "Mask";
-    _           14;
+    mask        1 type(int_mask) "Masked";
+    _           15;
   };
+  
+  register lvt_perf_cnt rw addr(base, 0x0340) type (lvt_mon);
   register lvt_thermal rw addr(base, 0x0330) type (lvt_mon);
-  register lvt_perfmon rw addr(base, 0x0340) type (lvt_mon);
 
   // 8.5.3
   register esr rw addr(base, 0x0280) "Error Status" {
index e0220f3..96da882 100644 (file)
@@ -121,6 +121,9 @@ errors kernel SYS_ERR_ {
 
     // Time synchronization errors
     failure SYNC_MISS                  "Missed synchronization phase",
+
+    // SCC driver errors
+    failure CROSS_MC                   "Frame crosses memory controllers",
 };
 
 // errors generated by libbarrelfish code
@@ -369,6 +372,10 @@ errors chips CHIPS_ERR_ {
     failure GET_SERVICE_REFERENCE "Error getting service reference from name service",
     failure GET_SERVICE_IREF      "Error getting IREF from name service",
     failure UNKNOWN_NAME          "Lookup failed: unknown name",
+    failure EXISTS               "Entry already exists",
+    failure GET_CAP              "Error getting a capability from store",
+    failure PUT_CAP              "Error putting a capability to store",
+    failure OUT_OF_SEMAPHORES    "Out of semaphores",
 };
 
 // errors generated by bcast library
@@ -490,6 +497,8 @@ errors spawn SPAWN_ERR_ {
     failure CREATE_DISPATCHER_FRAME "Failure creating dispatcher frame",
     failure CREATE_SELFEP       "Failure creating endpoint to self",
     failure CREATE_ARGSPG       "Failure creating page for arguments",
+    failure CREATE_FDSPG        "Failure creating page for file descriptors",
+    failure COPY_FDCAP          "Failure copying frame cap for file descriptors",
     failure MINT_ROOTCN         "Failure minting root CNode into task CNode",
     failure CREATE_SLOTALLOC_CNODE "Failure creating slot_alloc cnode",
 
@@ -498,6 +507,8 @@ errors spawn SPAWN_ERR_ {
     failure MAP_DISPATCHER_TO_SELF "Failure mapping dispatcher frame to parent",
     failure MAP_ARGSPG_TO_NEW   "Failure mapping arguments page to new domain",
     failure MAP_ARGSPG_TO_SELF  "Failure mapping arguments page to parent",
+    failure MAP_FDSPG_TO_NEW   "Failure mapping file descriptors page to new domain",
+    failure MAP_FDSPG_TO_SELF  "Failure mapping file descriptors page to parent",
     
     failure FILL_SMALLCN        "Failure filling smallcn of new domain",
     failure MAP_BOOTINFO        "Failure mapping bootinfo to new domain",
@@ -510,6 +521,10 @@ errors spawn SPAWN_ERR_ {
     failure ARGSPG_OVERFLOW     "Overflow in arguments page: too many arguments or environment variables",
     failure SERIALISE_VSPACE    "Error in serialising vspace data",
 
+    // setup file descriptors
+    failure SETUP_FDCAP         "Failure setting up frame for copying file descriptors",
+    failure FDSPG_OVERFLOW     "Overflow in file descriptors page: too many file descriptors",
+
     // spawn_free
     failure DELETE_ROOTCN       "Failure deleting root CNode cap in parent",
     failure FREE_ROOTCN         "Failure freeing slot for root CNode cap in parent",
@@ -520,9 +535,15 @@ errors spawn SPAWN_ERR_ {
     failure COPY_MODULECN       "Error copying module CNode cap",
     failure COPY_IRQ_CAP        "Error copying IRQ cap",
     failure COPY_IO_CAP         "Error copying IO cap",
+    failure COPY_PERF_MON      "Error copying performance monitoring cap",
 
     // make_runnable
     failure DISPATCHER_SETUP   "Dispatcher setup",
+
+    // domain management
+    failure DOMAIN_ALLOCATE    "No more domain descriptors",
+    failure DOMAIN_NOTFOUND    "Domain not found",
+    failure DOMAIN_RUNNING     "Domain is running",
 };
 
 // errors from ELF library
@@ -572,6 +593,7 @@ errors init INIT_ERR_ {
     failure COPY_SUPERCN_CAP    "Failed to copy superCN cap to mem_serv",
     failure MAP_BOOTINFO        "Failed to map bootinfo to child",
     failure COPY_KERNEL_CAP     "Failed to copy kernel cap to monitor",
+    failure COPY_PERF_MON       "Failed to copy performance monitoring cap to monitor",
     failure COPY_MODULECN_CAP   "Failed to copy module CNode cap to monitor",
     failure COPY_PACN_CAP       "Failed to copy phys addr CNode cap to monitor",
     failure COPY_IRQ_CAP        "Failed to copy IRQ cap to monitor",
@@ -600,15 +622,20 @@ errors filter PORT_ERR_ {
     failure NOT_ENOUGH_MEMORY   "Not enough memory for internals of port mng",
     failure NO_MORE_PORT        "No free port available",
     failure IN_USE              "Requested port is already in use",
+    failure REDIRECT            "Requested port cannot be redirected",
+    failure NOT_FOUND            "Could not find requested port to close",
 };
 
 
 //errors in Filter management
 errors filter FILTER_ERR_ {
     failure NOT_ENOUGH_MEMORY   "Not enough memory to register filters",
-    failure BUFF_NOT_FOUND     "Buffer given for filter reg. not found on driver",
+    failure BUFF_NOT_FOUND      "Buffer given for filter reg. not found on driver",
     failure FILTER_BUSY         "Filter memory is busy in another operation.Try Again",
-    failure NO_NETD_MEM                        "Netd memory for filter is not registered",
+    failure NO_NETD_MEM         "Netd memory for filter is not registered",
+    failure FILTER_NOT_FOUND    "requested filter for de/re-registration not found",
+    failure BUFFER_NOT_FOUND    "requested filter for re-registration not found",
+    
 };
 
 // errors generated in the terminal library
@@ -672,6 +699,8 @@ errors vfs VFS_ERR_ {
     failure IN_OPEN             "Nested error in vfs_open()",
     failure IN_STAT             "Nested error in vfs_stat()",
     failure IN_READ             "Nested error in vfs_read()",
+
+    failure BCACHE_LIMIT       "Number of buffer cache connections exceeded",
 };
 
 // NFS client errors
index 92d6615..ec19087 100644 (file)
@@ -53,7 +53,11 @@ trace = False
 
 -- Enable QEMU networking. (ie. make network work in small memory)
 support_qemu_networking :: Bool
-support_qemu_networking  = False
+support_qemu_networking  = True
+
+-- enable network tracing
+trace_network_subsystem :: Bool
+trace_network_subsystem = False
 
 -- May want to disable LRPC to improve trace visuals
 trace_disable_lrpc :: Bool
@@ -66,6 +70,9 @@ global_debug = False
 e1000n_debug :: Bool
 e1000n_debug = False
 
+eMAC_debug :: Bool
+eMAC_debug = False
+
 rtl8029_debug :: Bool
 rtl8029_debug = False
 
@@ -170,9 +177,11 @@ defines = [ Str ("-D" ++ d) | d <- [
              if microbenchmarks then "CONFIG_MICROBENCHMARKS" else "",
              if trace then "CONFIG_TRACE" else "",
              if support_qemu_networking then "CONFIG_QEMU_NETWORK" else "",
+             if trace_network_subsystem then "NETWORK_STACK_TRACE" else "",
              if trace_disable_lrpc then "TRACE_DISABLE_LRPC" else "",
              if global_debug then "GLOBAL_DEBUG" else "",
              if e1000n_debug then "E1000N_SERVICE_DEBUG" else "",
+             if eMAC_debug then "EMAC_SERVICE_DEBUG" else "",
              if rtl8029_debug then "RTL8029_SERVICE_DEBUG" else "",
              if ethersrv_debug then "ETHERSRV_SERVICE_DEBUG" else "",
              if netd_debug then "NETD_SERVICE_DEBUG" else "",
index 45fbc73..da834b0 100644 (file)
@@ -33,7 +33,8 @@ ourCommonFlags = [ Str "-m32",
                    Str "-mno-red-zone",
                    Str "-fPIE",
                    Str "-fno-stack-protector",
-                   Str "-D__scc__" ]
+                   Str "-D__scc__",
+                   Str "-march=pentium" ]
 
 
 commonCFlags = ArchDefaults.commonCFlags
@@ -67,7 +68,7 @@ options = (ArchDefaults.options arch archFamily) {
 -- The kernel is "different"
 --
 
-kernelCFlags = X86_32.kernelCFlags ++ [ Str "-march=pentium", 
+kernelCFlags = X86_32.kernelCFlags ++ [ Str "-march=pentium",
                                         Str "-D__scc__" ]
 kernelLdFlags = X86_32.kernelLdFlags
 
index 59507ea..fa17061 100644 (file)
@@ -31,7 +31,8 @@ cxxcompiler = "g++"
 ourCommonFlags = [ Str "-m32",
                    Str "-mno-red-zone",
                    Str "-fPIE",
-                   Str "-fno-stack-protector",  
+                   Str "-fno-stack-protector", 
+                  Str "-Wno-unused-but-set-variable", 
                    Str "-Wno-packed-bitfield-compat" ]
 
 cFlags = ArchDefaults.commonCFlags
@@ -85,6 +86,7 @@ kernelCFlags = [ Str s | s <- [ "-fno-builtin",
                                 "-Wmissing-field-initializers",
                                 "-Wredundant-decls",
                                 "-Wno-packed-bitfield-compat",
+                               "-Wno-unused-but-set-variable",
                                 "-Werror",
                                 "-imacros deputy/nodeputy.h",
                                 "-mno-mmx",
index e4c8c76..08a87f8 100644 (file)
@@ -32,6 +32,7 @@ ourCommonFlags = [ Str "-m64",
                    Str "-mno-red-zone",
                    Str "-fPIE",
                    Str "-fno-stack-protector", 
+                  Str "-Wno-unused-but-set-variable",
                    Str "-Wno-packed-bitfield-compat" ]
 
 cFlags = ArchDefaults.commonCFlags
@@ -83,6 +84,7 @@ kernelCFlags = [ Str s | s <- [ "-fno-builtin",
                                 "-Wmissing-field-initializers",
                                 "-Wredundant-decls",
                                 "-Wno-packed-bitfield-compat",
+                               "-Wno-unused-but-set-variable",
                                 "-Werror",
                                 "-imacros deputy/nodeputy.h",
                                 "-mno-mmx",
@@ -91,6 +93,7 @@ kernelCFlags = [ Str s | s <- [ "-fno-builtin",
                                 "-mno-sse3",
                                 "-mno-sse4.1",
                                 "-mno-sse4.2",
+--                             "-Wno-unused-but-set-variable",
                                 "-mno-sse4",
                                 "-mno-sse4a",
                                 "-mno-3dnow" ]]
index c43372a..f4bccba 100644 (file)
@@ -22,15 +22,21 @@ module      /scc/sbin/monitor
 
 module /scc/sbin/chips boot
 module /scc/sbin/ramfsd boot
-module  /scc/sbin/spawnd boot bootscc=
+module  /scc/sbin/spawnd boot bootscc=1
 module  /scc/sbin/startd boot
+# modules needed to start the networking
+# module  /scc/sbin/eMAC core=0
+# module  /scc/sbin/netd core=0 cardname=eMAC2_0
+# module  /scc/sbin/eMAC core=1
+# module  /scc/sbin/netd core=1 cardname=eMAC2_1
 
 # RCK memory map
 # Everything up til VGA is private RAM (maybe we want to throw it away)
 mmap   map     0x0             0xa000          2
 # Everything after VGA is private RAM (we also live in this area)
-mmap   map     0xe800          0x13ff1800      1
+mmap   map     0xe800          0x26ff1800      1
 # Shared RAM (over all MCs) in the middle of address space
-mmap   map     0x80000000      0x4000000       1
+#mmap  map     0x80000000      0x4000000       1
+mmap    map     0x80000000      0x40000000      1
 # At the very end we have some platform memory (bootup EEPROM)
 mmap   map     0xfffc0000      0x40000         2
index 1d53518..5c3947e 100644 (file)
@@ -33,9 +33,11 @@ module  /x86_64/sbin/startd boot
 ## For networking
 ## For qemu, enable rtl8029
 # module       /x86_64/sbin/rtl8029
+# module    /x86_64/sbin/netd cardname=rtl8029
+
 ## For real hardware, enable e1000n
 # module       /x86_64/sbin/e1000n
-# module       /x86_64/sbin/netd
+# module       /x86_64/sbin/netd cardname=e1000
 
 # General user domains
 module /x86_64/sbin/serial
index 9e3a225..974fa11 100644 (file)
@@ -52,6 +52,7 @@ MODULES_COMMON= \
        sbin/idctest \
        sbin/memtest \
        sbin/fread_test \
+       sbin/fscanf_test \
        sbin/monitor \
        sbin/ramfsd \
        sbin/routetest \
@@ -90,7 +91,7 @@ MODULES_x86_64= \
        sbin/e1000n \
        sbin/rtl8029 \
        sbin/netd \
-        sbin/echoserver \
+       sbin/echoserver \
        sbin/elver \
        sbin/fbdemo \
        sbin/fish \
@@ -133,6 +134,8 @@ MODULES_x86_64= \
        sbin/webserver \
        sbin/tlstest \
        sbin/timer_test \
+       sbin/net_openport_test \
+       sbin/examples/xmpl-perfmon \
        $(BIN_CONSENSUS) \
 
 # the following are broken in the newidc system
@@ -173,12 +176,16 @@ MODULES_scc=\
        $(BIN_RCCE_LU) \
        sbin/rcce_pingpong \
        sbin/bench \
+       sbin/eMAC \
+       sbin/netd \
+       sbin/webserver \
        sbin/ipirc_test \
        sbin/thc_v_flounder_empty \
        sbin/thcidctest \
        sbin/thcminitest \
        sbin/thctest \
        sbin/mem_serv_dist \
+       sbin/net-test \
 
 # ARM-specific modules to build by default
 MODULES_arm=\
@@ -339,7 +346,7 @@ scc: all tools/bin/dite
        cp $(SRCDIR)/tools/scc/bootvector.dat .
        bin2obj -m $(SRCDIR)/tools/scc/bigimage.map -o barrelfish0.obj
        @echo Taking the barrelfish.obj file to SCC host
-       scp barrelfish0.obj user@tomme2.in.barrelfish.org:
+       scp barrelfish0.obj user@tomme1.in.barrelfish.org:
 
 # M5 Simulation targets
 
index 646d469..d7bba84 100644 (file)
@@ -1,5 +1,5 @@
 --------------------------------------------------------------------------
--- Copyright (c) 2007-2010, ETH Zurich.
+-- Copyright (c) 2007-2011, ETH Zurich.
 -- All rights reserved.
 --
 -- This file is distributed under the terms in the attached LICENSE file.
@@ -54,8 +54,9 @@
                "xmplcr",
                "xmplmsg",
                "xmplrpc",
-               "xmplthc" ],
-
+               "xmplthc",
+               "unixsock",
+              "bcache" ],
              arch <- allArchitectures
 ] ++
 
diff --git a/if/bcache.if b/if/bcache.if
new file mode 100644 (file)
index 0000000..730fe9d
--- /dev/null
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+interface bcache "Buffer cache" {
+    typedef uint32 fsize; // file size type (4G ought to be enough ...!)
+
+    rpc new_client(out cap bulk);
+
+    rpc get_start(in char key[key_len], out uint64 index, out bool haveit, out uint64 transid, out uint64 size);
+    rpc get_stop(in uint64 transid, in uint64 index, in uint64 length);
+
+    rpc print_stats();
+};
index ca7e366..1b1d2dd 100644 (file)
@@ -8,60 +8,39 @@
  */
 
 interface ether_control "Generic Ethernet Driver Control flow Interface" {
-    
-    alias errval_t uint64;
 
     call register_filter_memory_request(cap mem);
-    response register_filter_memory_response(errval_t err);
+    response register_filter_memory_response(errval err);
 
     call register_filter_request(uint64 id,
                uint64 len_rx,
                        uint64 len_tx,
                        uint64 buffer_id_rx,
-                       uint64 buffer_id_tx);
+                       uint64 buffer_id_tx,
+                       uint64 filter_type);
     response register_filter_response(uint64 id,
-               errval_t err,
+               errval err,
                        uint64 filter_id,
                        uint64 buffer_id_rx,
-                       uint64 buffer_id_tx);
+                       uint64 buffer_id_tx,
+                       uint64 filter_type);
+
+    call re_register_filter_request(uint64 filter_id,
+            uint64 buffer_id_rx,
+            uint64 buffer_id_tx);
+    response re_register_filter_response(errval err,
+            uint64 filter_id,
+            uint64 buffer_id_rx,
+            uint64 buffer_id_tx);
 
     call deregister_filter_request(uint64 filter_id);
-    response deregister_filter_response(errval_t err,
+    response deregister_filter_response(errval err,
                        uint64 filter_id);
 
     call register_arp_filter_request(uint64 id, 
                uint64 len_rx,
                        uint64 len_tx);
     response register_arp_filter_response(uint64 id, 
-               errval_t err);
-
-/*
-    call register_netd_memory(cap mem);
-    response registered_netd_memory(errval_t err);
+               errval err);
 
-    call register_filter(uint64 id,
-               uint64 len_rx,
-                       uint64 len_tx,
-                       uint64 buffer_id_rx,
-                       uint64 buffer_id_tx);
-    response registered_filter(uint64 id,
-               errval_t err,
-                       uint64 filter_id,
-                       uint64 buffer_id_rx,
-                       uint64 buffer_id_tx);
-
-    call deregister_filter(uint64 filter_id,
-                       uint64 buffer_id_rx,
-                       uint64 buffer_id_tx);
-    response deregistered_filter(errval_t err,
-                       uint64 filter_id,
-                       uint64 buffer_id_rx,
-                       uint64 buffer_id_tx);
-
-    call register_arp_filter(uint64 id, 
-               uint64 len_rx,
-                       uint64 len_tx);
-    response registered_arp_filter(uint64 id, 
-               errval_t err);
-  */  
 };
index 117d001..e487bf5 100644 (file)
--- a/if/mem.if
+++ b/if/mem.if
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, 2011 ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -18,7 +18,9 @@ interface mem "Memory allocation RPC interface" {
              in genpaddr maxlimit,
              out errval ret,
              out give_away_cap mem_cap );
-  rpc available( out genpaddr mem_size );
-  rpc free( in give_away_cap mem_cap,
-           out errval ret );
+  rpc available( out genpaddr mem_avail, out genpaddr mem_total );
+
+  // XXX: Trusted call, may only be called by monitor.
+  // Should move this to its own binding.
+  rpc free_monitor(in give_away_cap mem_cap, in genpaddr base, in uint8 bits, out errval err);
 };
index 58f30fc..22210ca 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -132,13 +132,6 @@ interface monitor "The monitor to client Interface" {
 
           call set_mem_iref_request(
                         iref iref);
-          response set_mem_iref_reply(
-                        errval err);
-
-         call set_percore_iref_request(
-                       iref iref);
-         response set_percore_iref_reply(
-                       errval err);
 
           call set_name_iref_request(
                         iref iref);
index a3f970e..9fefd90 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -44,6 +44,9 @@ interface monitor_blocking "The monitor to client RPC interface" {
         // debug cap identify mechanism
         rpc cap_identify(in cap cap, out errval err, out caprep caprep);
 
+       // XXX: Hack to set a cap remote until we have x-core cap management
+       rpc cap_set_remote(in cap cap, in bool remote, out errval err);
+
         /* Allocate local IRQ vector */
         rpc irq_handle(in cap ep, out errval err, out uint32 vector);
 };
index b5d6bee..a9379fb 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -19,4 +19,14 @@ interface nameservice "Name server (chips) interface" {
     //rpc get_service_references(in string iface, in string filter, out srvref_seq srvrefs);
     rpc wait_for_service_reference(in string iface, out srvref ref);
     rpc get_service(in srvref srvref, out iref iref);
+
+    // Simple capability storage
+    rpc get_cap(in string key, out cap retcap, out errval reterr);
+    rpc put_cap(in string key, in cap storecap, out errval reterr);
+
+    // Shared-memory semaphores
+    rpc sem_new(in uint32 value, out uint32 sem, out errval reterr);
+    rpc sem_post(in uint32 sem);
+    rpc sem_wait(in uint32 sem);
+    rpc sem_trywait(in uint32 sem, out bool success);
 };
index f2e66f7..3db8d50 100644 (file)
@@ -33,5 +33,15 @@ interface netd "Network Daemon" {
     rpc close_port(in port_type type, 
                   in uint16 port_no,
                    out errval err);
+
+    rpc redirect(in port_type port,
+                           in ipv4addr local_ip,               
+                   in uint16 local_port,
+                   in ipv4addr remote_ip,
+                   in uint16 remote_port,
+                    in bufid buffer_id_rx,
+                    in bufid buffer_id_tx,
+                     out errval err);
+
 };
 
index b183cbd..ba95238 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -8,7 +8,29 @@
  */
 
 interface spawn "Interface to spawn domains" {
+    typedef struct {
+       uint8 status;
+    } ps_entry;
+
     rpc spawn_domain(in string path, in char argvbuf[argvbytes], in char envbuf[envbytes],
                      out errval err, out domainid domain_id);
+    rpc spawn_domain_with_fdcap(in string path, in char argvbuf[argvbytes], 
+                               in char envbuf[envbytes], in cap fdcap,
+                                out errval err, out domainid domain_id);
     rpc use_local_memserv();
+    rpc kill(in domainid domain_id, out errval err);
+
+    /*
+     * XXX: domain_id shouldn't be here. Instead, spawnd should figure
+     * out from the binding what domain it is sending the request.
+     */
+    rpc exit(in domainid domain_id, in uint8 exitcode);
+
+    rpc wait(in domainid domain_id, in bool nohang, out uint8 exitcode, out errval err);
+
+    // XXX: Should be domainid instead of uint8, but it's not yet supported
+    rpc get_domainlist(out uint8 domains[len]);
+
+    rpc status(in domainid domain_id, out ps_entry ps_entry, out char argv[len],
+              out errval err);
 };
diff --git a/if/unixsock.if b/if/unixsock.if
new file mode 100644 (file)
index 0000000..eaccdda
--- /dev/null
@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+interface unixsock "UNIX socket" {
+         message send(uint8 msg[size]);
+};
index 00eab7c..60943ff 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -57,6 +57,7 @@ typedef uintptr_t       mem_ptr_t;
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/time.h>
 
 #define LWIP_PLATFORM_DIAG(x)   do {printf x;} while(0)
 #define LWIP_PLATFORM_ASSERT(x) do {printf("Assertion \"%s\" failed at line %d in %s\n", \
index f0c3100..61db8be 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
 #ifndef SYS_ARCH_H
 #define SYS_ARCH_H
 
+#include <barrelfish/barrelfish.h>
+
 /// Protection level
 typedef u8_t    sys_prot_t;
 
-// XXX: Still need to be implemented
-typedef u8_t sys_sem_t;
-typedef u8_t sys_mbox_t;
-struct sys_timeo {u8_t dummy;};
-
-// XXX: Still need to be implemented
-#define sys_init()
-#define sys_timeout(m,h,a)
-#define sys_untimeout(m,a)
-#define sys_sem_new(c) c
-#define sys_sem_signal(s)
-#define sys_sem_wait(s)
-#define sys_sem_wait_timeout(s,t)
-#define sys_arch_sem_wait(s,t)
-#define sys_sem_free(s)
-#define sys_mbox_new(s) 0
-#define sys_mbox_fetch(m,d)
-#define sys_mbox_tryfetch(m,d)
-#define sys_mbox_post(m,d)
-#define sys_mbox_trypost(m,d)
-#define sys_mbox_free(m)
-#define sys_thread_new(n,t,a,s,p)
+typedef struct thread_wrapper *sys_thread_t;
+
+typedef struct thread_sem *sys_sem_t;
+
+struct bf_sys_mbox {
+    void *msg;
+    bool empty;
+    struct thread_mutex mutex;
+    struct thread_cond changed_cond;
+};
+typedef struct bf_sys_mbox * sys_mbox_t;
+
+
+#define SYS_MBOX_NULL   0
+#define SYS_SEM_NULL    0
 
 #endif
diff --git a/include/arch/x86/barrelfish_kpi/perfmon.h b/include/arch/x86/barrelfish_kpi/perfmon.h
new file mode 100644 (file)
index 0000000..5de715e
--- /dev/null
@@ -0,0 +1,38 @@
+/**
+ * \file
+ * \brief Performace monitoring support for x86\
+ * This should be working on Intel and AMD platforms.
+ */
+
+/*
+ * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+
+#ifndef BARRELFISH_KPI_PERFMON_H
+#define BARRELFISH_KPI_PERFMON_H
+
+#include <barrelfish_kpi/lmp.h>
+
+#define min_pm(a,b) ((a) < (b) ? (a) : (b))
+
+// LMP_MAX_LENGTH is given in words, need to convert to bytes.
+#define LMP_MAX_BYTES (LMP_MSG_LENGTH*sizeof(uint64_t)/sizeof(char))
+
+// Make sure the size of the struct does not exceed the maximum
+// length used for message transfer
+#define PERFMON_DATA_LEN (min_pm(DISP_NAME_LEN, LMP_MAX_BYTES))
+#define PERFMON_DISP_NAME_LEN (PERFMON_DATA_LEN-sizeof(uint64_t))
+
+struct perfmon_overflow_data {
+    uint64_t ip; // Instruction pointer when overflow was fired
+    char name[PERFMON_DISP_NAME_LEN]; // Name of the running task
+};
+
+#endif //BARRELFISH_KPI_PERFMON_H
+
index d45d8e8..6dc5e8e 100644 (file)
@@ -218,6 +218,37 @@ static inline errval_t invoke_frame_identify(struct capref frame,
     return sysret.error;
 }
 
+#ifdef __scc__
+/**
+ * \brief Return the physical address and size of a frame capability
+ *
+ * \param frame    CSpace address of frame capability
+ * \param ret      frame_identity struct filled in with relevant data
+ *
+ * \return Error code
+ */
+static inline errval_t invoke_scc_frame_identify(struct capref frame,
+                                                 struct scc_frame_identity *ret)
+{
+    uint8_t invoke_bits = get_cap_valid_bits(frame);
+    caddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
+
+    struct sysret sysret =
+        syscall2((invoke_bits << 16) | (FrameCmd_SCC_Identify << 8)
+                 | SYSCALL_INVOKE, invoke_cptr);
+
+    assert(ret != NULL);
+    if (err_is_ok(sysret.error)) {
+        ret->route = sysret.value & 0xff;
+        ret->subdest = (sysret.value >> 8) & 0xff;
+        ret->addrbits = sysret.value >> 16;
+        return sysret.error;
+    }
+
+    return sysret.error;
+}
+#endif
+
 static inline errval_t invoke_iocap_in(struct capref iocap, enum io_cmd cmd,
                                        uint16_t port, uint32_t *data)
 {
@@ -407,3 +438,17 @@ invoke_monitor_get_arch_id(uintptr_t *core_id)
 
     return sysret.error;
 }
+
+static inline errval_t invoke_perfmon_activate(struct capref perfmon_cap,
+                                               uint8_t event, uint8_t perf_umask, 
+                                               bool kernel, uint8_t counter_id,
+                                               uint64_t counter_value, 
+                                               caddr_t ep_addr)
+{
+    return ERR_NOTIMP;
+}
+
+static inline errval_t invoke_perfmon_deactivate(struct capref perfmon_cap)
+{
+    return ERR_NOTIMP;
+}
index 1f50a30..e02eb83 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
 
 #ifdef __scc__
 #define SHARED_MEM_MIN          0x80000000
-#define SHARED_MEM_MAX          0x84000000
-#define SHARED_MEM_SIZE         0x4000000
-#define PERCORE_MEM_SIZE        0x100000
+#define SHARED_MEM_MAX          0xc0000000
+/* #define SHARED_MEM_MAX          0x84000000 */
+#define SHARED_MEM_SIZE         0x40000000
+/* #define SHARED_MEM_SIZE         0x4000000 */
+#define PERCORE_MEM_SIZE        0x1000000
+/* #define PERCORE_MEM_SIZE        0x100000 */
+
+#define PRIVATE_MEM_MAX          0x27000000
+
+#define EXTRA_SHARED_MEM_MIN    0x70000000
+#define EXTRA_SHARED_MEM_MAX    0x80000000
+
 #endif
 
 #endif // ARCH_SCC_BARRELFISH_KPI_SHARED_MEM_H
index b460f2c..41bccab 100644 (file)
@@ -287,19 +287,27 @@ static inline errval_t invoke_kernel_get_core_id(struct capref kern_cap,
     return sysret.error;
 }
 
-static inline errval_t invoke_perfmon_setup(struct capref dispcap,
-                                            uint8_t counter, uint64_t evt,
-                                            uint64_t umsk, bool os)
+static inline errval_t invoke_perfmon_activate(struct capref perfmon_cap,
+                                               uint8_t event, uint8_t perf_umask, 
+                                               bool kernel, uint8_t counter_id,
+                                               uint64_t counter_value, 
+                                               caddr_t ep_addr)
 {
-    return cap_invoke6(dispcap, DispatcherCmd_PerfMon, counter, 0, evt, umsk,
-                       os ? 1 : 0).error;
+    return cap_invoke7(perfmon_cap, PerfmonCmd_Activate, 
+                       event, perf_umask, counter_id, kernel, 
+                       counter_value, ep_addr).error;
 }
 
-static inline errval_t invoke_perfmon_write(struct capref dispcap,
-                                            uint8_t counter, uint64_t value)
+static inline errval_t invoke_perfmon_write(struct capref perfmon_cap,
+                                                  uint8_t counter_id,
+                                                  uint64_t counter_value)
 {
-    return 
-       cap_invoke4(dispcap, DispatcherCmd_PerfMon, counter, 1, value).error;
+    return cap_invoke3(perfmon_cap, PerfmonCmd_Write, counter_id, counter_value).error;
+}
+
+static inline errval_t invoke_perfmon_deactivate(struct capref perfmon_cap)
+{
+    return cap_invoke1(perfmon_cap, PerfmonCmd_Deactivate).error;
 }
 
 static inline errval_t
diff --git a/include/arpa/inet.h b/include/arpa/inet.h
new file mode 100644 (file)
index 0000000..c160458
--- /dev/null
@@ -0,0 +1,6 @@
+#ifndef _ARPA_INET_H
+#define _ARPA_INET_H
+
+#include <lwip/sockets.h>
+
+#endif
index c8bde9f..f31f775 100644 (file)
@@ -43,7 +43,7 @@ void bulk_destroy(struct bulk_transfer *bt);
 errval_t bulk_init(void *mem, size_t size, size_t block_size,
                    struct bulk_transfer *bt);
 errval_t bulk_create(size_t size, size_t block_size, struct capref *shared_mem,
-                     struct bulk_transfer *bt);
+                     struct bulk_transfer *bt, bool LMP_only);
 struct bulk_buf *bulk_alloc(struct bulk_transfer *bt);
 errval_t bulk_free(struct bulk_transfer *bt, uintptr_t id);
 
index 6a75c14..69dbaf3 100644 (file)
@@ -55,7 +55,7 @@ extern struct cnoderef cnode_root, cnode_task, cnode_base,
 
 /* well-known capabilities */
 extern struct capref cap_root, cap_monitorep, cap_irq, cap_io, cap_dispatcher,
-    cap_selfep, cap_kernel, cap_initep, cap_bmptable;
+  cap_selfep, cap_kernel, cap_initep, cap_bmptable, cap_perfmon, cap_dispframe;
 
 /**
  * \brief Returns the number of valid bits in the CSpace address of a cap
index 45b0abe..30efe80 100644 (file)
@@ -52,7 +52,6 @@ struct ram_alloc_state {
     errval_t mem_connect_err;
     struct thread_mutex ram_alloc_lock;
     ram_alloc_func_t ram_alloc_func;
-    ram_free_func_t ram_free_func;
     uint64_t default_minbase;
     uint64_t default_maxlimit;
     int base_capnum;
index 31cd76f..0b0d426 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2008, 2010, ETH Zurich.
+ * Copyright (c) 2008, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -18,6 +18,7 @@
 struct capability;
 errval_t debug_cap_identify(struct capref cap, struct capability *ret);
 void debug_cspace(struct capref root);
+void debug_my_cspace(void);
 void debug_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 int debug_print_cap(char *buf, size_t len, struct capability *cap);
 int debug_print_cap_at_capref(char *buf, size_t len, struct capref cap);
index a67ab64..02754cd 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -75,6 +75,9 @@ struct dispatcher_generic {
 
     /// Last FPU-using thread
     struct thread *fpu_thread;
+
+    /// Domain ID cache
+    domainid_t domain_id;
 };
 
 #endif // BARRELFISH_DISPATCHER_H
index 685d9fb..1e47360 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2009, 2010, ETH Zurich.
+ * Copyright (c) 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -27,6 +27,7 @@ struct spawn_rpc_client;
 struct waitset *get_default_waitset(void);
 void disp_set_core_id(coreid_t core_id);
 coreid_t disp_get_core_id(void);
+domainid_t disp_get_domain_id(void);
 coreid_t disp_handle_get_core_id(dispatcher_handle_t handle);
 void set_monitor_binding(struct monitor_binding *b);
 struct monitor_binding *get_monitor_binding(void);
index f7f9f43..6138f65 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2009, 2010, ETH Zurich.
+ * Copyright (c) 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -64,6 +64,7 @@ errval_t lmp_chan_accept(struct lmp_chan *lc, size_t buflen_words,
 errval_t lmp_chan_register_send(struct lmp_chan *lc, struct waitset *ws,
                                 struct event_closure closure);
 errval_t lmp_chan_deregister_send(struct lmp_chan *lc);
+void lmp_chan_migrate_send(struct lmp_chan *lc, struct waitset *ws);
 errval_t lmp_chan_alloc_recv_slot(struct lmp_chan *lc);
 void lmp_channels_retry_send_disabled(dispatcher_handle_t handle);
 void lmp_init(void);
@@ -97,6 +98,19 @@ static inline errval_t lmp_chan_deregister_recv(struct lmp_chan *lc)
 }
 
 /**
+ * \brief Migrate an event registration made with
+ * lmp_chan_register_recv() to a new waitset
+ *
+ * \param lc LMP channel
+ * \param ws New waitset
+ */
+static inline void lmp_chan_migrate_recv(struct lmp_chan *lc,
+                                         struct waitset *ws)
+{
+    lmp_endpoint_migrate(lc->endpoint, ws);
+}
+
+/**
  * \brief Receive a message from an LMP channel, if possible
  *
  * Non-blocking. May fail if no message is available.
index 81bbbc4..5704c9b 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2009, 2010, ETH Zurich.
+ * Copyright (c) 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -72,6 +72,7 @@ errval_t lmp_endpoint_recv(struct lmp_endpoint *ep, struct lmp_recv_buf *buf,
 errval_t lmp_endpoint_register(struct lmp_endpoint *ep, struct waitset *ws,
                                struct event_closure closure);
 errval_t lmp_endpoint_deregister(struct lmp_endpoint *ep);
+void lmp_endpoint_migrate(struct lmp_endpoint *ep, struct waitset *ws);
 void lmp_endpoint_store_lrpc_disabled(struct lmp_endpoint *ep, uint32_t bufpos,
                                       uintptr_t arg1, uintptr_t arg2,
                                       uintptr_t arg3, uintptr_t arg4);
index 06e96e1..9109b6e 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2010, ETH Zurich.
+ * Copyright (c) 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -41,4 +41,6 @@ errval_t monitor_client_new_binding(monitor_bind_cont_fn *cont, void *st,
 
 errval_t monitor_client_blocking_rpc_init(void);
 
+errval_t monitor_cap_set_remote(struct capref cap, bool remote);
+
 #endif // BARRELFISH_MONITOR_CLIENT_H
index 39ce416..254b3a0 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, ETH Zurich.
+ * Copyright (c) 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -15,4 +15,7 @@ errval_t nameservice_blocking_lookup(const char *iface, iref_t *retiref);
 errval_t nameservice_register(const char *iface, iref_t iref);
 errval_t nameservice_client_blocking_bind(void);
 
+errval_t nameservice_get_capability(const char *key, struct capref *retcap);
+errval_t nameservice_put_capability(const char *key, struct capref cap);
+
 #endif // BARRELFISH_NAMESERVICE_CLIENT_H
diff --git a/include/barrelfish/net_constants.h b/include/barrelfish/net_constants.h
new file mode 100644 (file)
index 0000000..f1aec84
--- /dev/null
@@ -0,0 +1,132 @@
+/**
+ * \file net_constants.h
+ * \brief File to hold the constants needed by network stack
+ * across driver, userspace and control plane values.
+ */
+
+/*
+ * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef LIBBARRELFISH_NETCONSTANTS_H
+#define LIBBARRELFISH_NETCONSTANTS_H
+
+#define FILTER_SERVICE_SUFFIX      "_FILT"
+
+#define CTL_SERVICE_SUFFIX          "_CTRL"
+
+
+
+#ifdef CONFIG_QEMU_NETWORK
+
+#if !defined(__scc__)
+/// Size of (static) heap memory
+#ifndef MEM_SIZE
+#define MEM_SIZE            (60*1024)
+#endif // MEM_SIZE
+
+/// Number of PBUF structs available
+#ifndef MEMP_NUM_PBUF
+#define MEMP_NUM_PBUF           128
+#endif // MEMP_NUM_PBUF
+
+/// Number of PBUF buffers available
+#ifndef PBUF_POOL_SIZE
+#define PBUF_POOL_SIZE          128
+#endif // PBUF_POOL_SIZE
+
+/* Used in the ethersrv.c and the driver. */
+#define RECEIVE_BUFFERS 128
+#define TRANSMIT_BUFFERS 128 //< Number of transmit descriptors
+                              //< (must be multiple of 8)
+
+/// the size of the pool
+#ifndef PBUF_POOL_BUFSIZE
+#define PBUF_POOL_BUFSIZE       (4 * 2048)
+#endif // PBUF_POOL_BUFSIZE
+
+/* from where the memory conf is coming? */
+#ifndef MEM_CONF_LOC
+#define MEM_CONF_LOC     "for_qemu"
+#endif // MEM_CONF_LOC
+
+#else // !defined(__scc__)
+
+/************** SCC machine ******************/
+/// Size of (static) heap memory
+#ifndef MEM_SIZE
+#define MEM_SIZE            (60*1024)
+#endif // MEM_SIZE
+
+/// Number of PBUF structs available
+#ifndef MEMP_NUM_PBUF
+#define MEMP_NUM_PBUF           2024
+#endif // MEMP_NUM_PBUF
+
+/// Number of PBUF buffers available
+#ifndef PBUF_POOL_SIZE
+#define PBUF_POOL_SIZE          2024
+#endif // PBUF_POOL_SIZE
+
+/* Used in the ethersrv.c and the driver. */
+#define RECEIVE_BUFFERS 1024
+#define TRANSMIT_BUFFERS 1024 //< Number of transmit descriptors
+                              //< (must be multiple of 8)
+
+/// the size of the pool
+#ifndef PBUF_POOL_BUFSIZE
+#define PBUF_POOL_BUFSIZE       (4 * 2048)
+#endif // PBUF_POOL_BUFSIZE
+
+/* from where the memory conf is coming? */
+#ifndef MEM_CONF_LOC
+#define MEM_CONF_LOC     "for_scc"
+#endif // MEM_CONF_LOC
+
+
+#endif // !defined(__scc__)
+
+
+#else // CONFIG_QEMU_NETWORK
+#ifndef MEM_SIZE
+#define MEM_SIZE                (60*1024*1024)
+#endif // MEM_SIZE
+
+/// Number of PBUF structs available
+#ifndef MEMP_NUM_PBUF
+#define MEMP_NUM_PBUF           16384
+#endif // MEMP_NUM_PBUF
+
+/// Number of PBUF buffers available
+#ifndef PBUF_POOL_SIZE
+#define PBUF_POOL_SIZE          16384
+#endif // PBUF_POOL_SIZE
+
+/* NOTE: This value should be bigger than NR_PREALLOCATED_PBUFS of lwipopts.h */
+/* Used in the ethersrv.c and the driver. */
+#define RECEIVE_BUFFERS 2048
+#define TRANSMIT_BUFFERS 2048 //< Number of transmit descriptors
+                              //< (must be multiple of 8)
+
+/// the size of the pool
+#ifndef PBUF_POOL_BUFSIZE
+#define PBUF_POOL_BUFSIZE       (4 * 2048)
+#endif // PBUF_POOL_BUFSIZE
+
+/* from where the memory conf is coming? */
+#ifndef MEM_CONF_LOC
+#define MEM_CONF_LOC     "BIG"
+#endif // MEM_CONF_LOC
+
+#endif // CONFIG_QEMU_NETWORK
+
+/* NOTE: This value should be smaller than RECEIVE_BUFFERS of ethersrv.h */
+#define NR_PREALLOCATED_PBUFS       ( RECEIVE_BUFFERS - 1)
+
+
+#endif // LIBBARRELFISH_NETCONSTANTS_H
index b862b7c..3a9eb96 100644 (file)
 
 typedef errval_t (* ram_alloc_func_t)(struct capref *ret, uint8_t size_bits,
                                       uint64_t minbase, uint64_t maxlimit);
-typedef errval_t (* ram_free_func_t)(struct capref cap);
 
 errval_t ram_alloc_fixed(struct capref *ret, uint8_t size_bits,
                          uint64_t minbase, uint64_t maxlimit);
 errval_t ram_alloc(struct capref *retcap, uint8_t size_bits);
-errval_t ram_alloc_set(ram_alloc_func_t local_allocator,
-                       ram_free_func_t local_free);
+errval_t ram_alloc_set(ram_alloc_func_t local_allocator);
 void ram_set_affinity(uint64_t minbase, uint64_t maxlimit);
 void ram_get_affinity(uint64_t *minbase, uint64_t *maxlimit);
 void ram_alloc_init(void);
-errval_t ram_free_fixed(struct capref ramcap);
-errval_t ram_free(struct capref ramcap);
 
 #endif // BARRELFISH_RAM_ALLOC_H
index df55773..4a0313e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, ETH Zurich.
+ * Copyright (c) 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -22,12 +22,19 @@ typedef enum spawn_flags {
 /* XXX: utility function that doesn't really belong here */
 const char *cpu_type_to_archstr(enum cpu_type cpu_type);
 
+errval_t spawn_program_with_fdcap(coreid_t coreid, const char *path,
+                       char *const argv[], char *const envp[],
+                       struct capref fdcap,
+                       spawn_flags_t flags, domainid_t *ret_domainid);
 errval_t spawn_program(coreid_t coreid, const char *path,
                        char *const argv[], char *const envp[],
                        spawn_flags_t flags, domainid_t *ret_domainid);
 errval_t spawn_program_on_all_cores(bool same_core, const char *path,
                                     char *const argv[], char *const envp[],
                                     spawn_flags_t flags, domainid_t *ret_domainid);
-errval_t spawn_set_local_memserv(coreid_t coreid);
+errval_t spawn_kill(domainid_t domainid);
+errval_t spawn_exit(uint8_t exitcode);
+errval_t spawn_wait(domainid_t domainid, uint8_t *exitcode, bool nohang);
+errval_t spawn_rpc_client(coreid_t coreid, struct spawn_rpc_client **ret_client);
 
 #endif // BARRELFISH_SPAWN_CLIENT_H
index 0088c2f..3cc87c6 100644 (file)
@@ -38,4 +38,9 @@ errval_t sys_debug_hardware_timer_read(uintptr_t* ret);
 errval_t sys_debug_hardware_timer_hertz_read(uintptr_t* ret);
 errval_t sys_debug_get_apic_ticks_per_sec(uint32_t *ret);
 
+#ifdef ENABLE_FEIGN_FRAME_CAP
+errval_t sys_debug_feign_frame_cap(struct capref slot, lpaddr_t base,
+                                   uint8_t bits);
+#endif
+
 #endif //BARRELFISH_SYS_DEBUG_H
diff --git a/include/barrelfish/thread_sync.h b/include/barrelfish/thread_sync.h
new file mode 100644 (file)
index 0000000..b147757
--- /dev/null
@@ -0,0 +1,57 @@
+/**
+ * \file
+ * \brief Thread synchronization definitions.
+ */
+
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef LIBBARRELFISH_THREAD_SYNC_H
+#define LIBBARRELFISH_THREAD_SYNC_H
+
+#include <stdint.h>
+#include <barrelfish_kpi/spinlocks_arch.h>
+
+/// A thread of execution
+struct thread;
+
+struct thread_mutex {
+    volatile int        locked;
+    struct thread       *queue;
+    spinlock_t          lock;
+    struct thread       *holder;
+};
+#ifndef __cplusplus
+#       define THREAD_MUTEX_INITIALIZER \
+    { .locked = false, .queue = NULL, .lock = 0 }
+#else
+#       define THREAD_MUTEX_INITIALIZER                                \
+    { false, (struct thread *)NULL, 0, (struct thread *)NULL }
+#endif
+
+struct thread_cond {
+    struct thread       *queue;
+    spinlock_t          lock;
+};
+#ifndef __cplusplus
+#       define THREAD_COND_INITIALIZER \
+    { .queue = NULL, .lock = 0 }
+#else
+#       define THREAD_COND_INITIALIZER \
+    { (struct thread *)NULL, 0 }
+#endif
+
+struct thread_sem {
+    volatile unsigned int       value;
+    struct thread               *queue;
+    spinlock_t                  lock;
+};
+#define THREAD_SEM_INITIALIZER          { .value = 0, .queue = NULL, .lock = 0 }
+
+#endif
index b354a23..6da13e9 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
 #ifndef LIBBARRELFISH_THREADS_H
 #define LIBBARRELFISH_THREADS_H
 
-#include <barrelfish_kpi/spinlocks_arch.h>
+#include <barrelfish/thread_sync.h>
 
 typedef int (*thread_func_t)(void *);
 
-/// A thread of execution
-struct thread;
-
-struct thread_mutex {
-    volatile int        locked;
-    struct thread       *queue;
-    spinlock_t          lock;
-    struct thread       *holder;
-};
-#ifndef __cplusplus
-#       define THREAD_MUTEX_INITIALIZER \
-    { .locked = false, .queue = NULL, .lock = 0 }
-#else
-#       define THREAD_MUTEX_INITIALIZER                                \
-    { false, (struct thread *)NULL, 0, (struct thread *)NULL }
-#endif
-
-struct thread_cond {
-    struct thread       *queue;
-    spinlock_t          lock;
-};
-#ifndef __cplusplus
-#       define THREAD_COND_INITIALIZER \
-    { .queue = NULL, .lock = 0 }
-#else
-#       define THREAD_COND_INITIALIZER \
-    { (struct thread *)NULL, 0 }
-#endif
-
-/// A thread of execution
-struct thread;
-
 /// Default size of a thread's stack
 #define THREADS_DEFAULT_STACK_BYTES     (64 * 1024)
 
@@ -83,13 +51,6 @@ void thread_cond_signal(struct thread_cond *cond);
 void thread_cond_broadcast(struct thread_cond *cond);
 void thread_cond_wait(struct thread_cond *cond, struct thread_mutex *mutex);
 
-struct thread_sem {
-    volatile unsigned int       value;
-    struct thread               *queue;
-    spinlock_t                  lock;
-};
-#define THREAD_SEM_INITIALIZER          { .value = 0, .queue = NULL, .lock = 0 }
-
 void thread_sem_init(struct thread_sem *sem, unsigned int value);
 void thread_sem_wait(struct thread_sem *sem);
 bool thread_sem_trywait(struct thread_sem *sem);
index 7d45cc0..b9a59a2 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -30,8 +30,6 @@ typedef size_t cycles_t;
 #define PRIXCYCLES "zX"
 #endif
 
-typedef intptr_t off_t;
-
 typedef uint32_t iref_t;
 
 #define NULL_IREF 0
index 9f4906a..d794f1e 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2009, 2010, ETH Zurich.
+ * Copyright (c) 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -37,7 +37,7 @@ lvaddr_t vspace_genvaddr_to_lvaddr(genvaddr_t genvaddr);
 errval_t vspace_current_init(bool init_domain);
 errval_t vspace_init(struct vspace* vspace, struct pmap *pmap);
 errval_t vspace_destroy(struct vspace* vspace);
-struct vregion* vspace_get_region(struct vspace* vspace, void *addr);
+struct vregion* vspace_get_region(struct vspace* vspace, const void *addr);
 errval_t vspace_pagefault_handler(struct vspace* vspace, lvaddr_t addr,
                                   vm_fault_type_t type);
 
index 29cd8d5..79d5419 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2009, 2010, ETH Zurich.
+ * Copyright (c) 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -30,7 +30,7 @@ typedef uint32_t vregion_flags_t;
 #include <barrelfish/vspace.h>
 #include <barrelfish/vspace_mmu_aware.h>
 
-errval_t vspace_unmap(void *buf);
+errval_t vspace_unmap(const void *buf);
 errval_t vspace_map_anon_attr(void **retaddr, struct memobj **ret_memobj,
                               struct vregion **ret_vregion, size_t size,
                               size_t *retsize, vregion_flags_t flags);
index df6d800..aa61dbf 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -46,7 +46,7 @@ struct dcb;
 
 static inline bool type_is_vnode(enum objtype type)
 {
-    STATIC_ASSERT(26 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(27 == ObjType_Num, "Check VNode definitions");
 
     return (type == ObjType_VNode_x86_64_pml4 ||
             type == ObjType_VNode_x86_64_pdpt ||
@@ -70,7 +70,7 @@ static inline bool type_is_vnode(enum objtype type)
 static inline size_t vnode_objbits(enum objtype type)
 {
     // This function should be emitted by hamlet or somesuch.
-    STATIC_ASSERT(26 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(27 == ObjType_Num, "Check VNode definitions");
 
     if (type == ObjType_VNode_x86_64_pml4 ||
         type == ObjType_VNode_x86_64_pdpt ||
@@ -152,7 +152,8 @@ enum dispatcher_cmd {
  * Frame capability commands.
  */
 enum frame_cmd {
-    FrameCmd_Identify   ///< Return physical address of frame
+    FrameCmd_Identify,   ///< Return physical address of frame
+    FrameCmd_SCC_Identify,      ///< Return MC route to frame
 };
 
 /**
@@ -190,6 +191,17 @@ enum notify_cmd {
     NotifyCmd_Send
 };
 
+
+/**
+ * Performance monitoring commands.
+ * Seems to be already included in the Dispatcher capability.
+ */
+enum perfmon_cmd {
+    PerfmonCmd_Activate,    ///< Activate performance counters
+    PerfmonCmd_Deactivate,  ///< Deactivate performance counters 
+    PerfmonCmd_Write        ///< Read current performance counter values
+};
+
 /**
  * Maximum command ordinal.
  */
@@ -203,6 +215,13 @@ struct frame_identity {
     uint8_t bits;      ///< Size of frame, in bits
 };
 
+#ifdef __scc__
+struct scc_frame_identity {
+    uint8_t route, subdest;
+    uint16_t addrbits;
+};
+#endif
+
 #endif // __ASSEMBLER__
 
 #endif // BARRELFISH_CAPABILITIES_H
index a8d9c33..d259c52 100644 (file)
 #define MAX_ENVIRON_VARS   128
 
 /**
+ * Size of page with inherited file descriptors
+ */
+#define FDS_SIZE          (32 * 1024)  // estimate worst case here.
+
+
+/**
  * Size of dispatcher frame
  */
 #define DISPATCHER_SIZE         ((genpaddr_t)1 << DISPATCHER_FRAME_BITS)
 #define TASKCN_SLOT_ARGSPAGE    10  ///< ?
 #define TASKCN_SLOT_MON_URPC    11  ///< Frame cap for urpc comm.
 #define TASKCN_SLOT_BMP_TABLE   12  ///< cap to access BMP association table
-#define TASKCN_SLOTS_USER       13  ///< First free slot in taskcn for user
+#define TASKCN_SLOT_FDSPAGE     13  ///< cap for performance monitoring
+#define TASKCN_SLOT_PERF_MON    14  ///< cap for performance monitoring
+#define TASKCN_SLOTS_USER       15  ///< First free slot in taskcn for user
 
 /// Address bits resolved for the standard CNodes (taskcn, supercn, base_page_cn)
 #define DEFAULT_CN_ADDR_BITS    (CPTR_BITS - DEFAULT_CNODE_BITS)
index 7e16c0e..0d9431e 100644 (file)
@@ -28,7 +28,8 @@ enum debug_message {
     DEBUG_HARDWARE_TIMER_HERTZ_READ,
     DEBUG_GET_TSC_PER_MS,
     DEBUG_GET_APIC_TIMER,
-    DEBUG_GET_APIC_TICKS_PER_SEC
+    DEBUG_GET_APIC_TICKS_PER_SEC,
+    DEBUG_FEIGN_FRAME_CAP,
 };
 
 #endif //BARRELFISH_KPI_SYS_DEBUG_H
index 1236357..f481858 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -28,6 +28,26 @@ typedef enum
     CPIO_MODE_UMASK          = 0000777
 } cpio_mode_bits_t;
 
+typedef struct
+{
+    cpio_mode_bits_t mode;
+    const char*      name;
+    const uint8_t*   data;
+    size_t           datasize;
+    uint32_t         checksum;
+} cpio_generic_header_t;
+
+/**
+ * CPIO visitor function.
+ *
+ * This is invoked by cpio_visit.
+ *
+ * returns zero to continue visit after current invocation, non-zero to stop.
+ */
+typedef int (*cpio_visitor_t)(int                          ordinal,
+                              const cpio_generic_header_t* header,
+                              void*                        arg);
+
 /**
  * Find file with specified in CPIO binary image.
  *
@@ -95,4 +115,23 @@ cpio_archive_valid(
     size_t          cpio_bytes
 );
 
+/**
+ * Apply visitor function to each header in CPIO memory image.
+ *
+ * @param cpio_base     base of CPIO memory image.
+ * @param cpio_bytes    size of CPIO memory image in bytes.
+ * @param cpio_visit_fn visitor function.
+ * @param arg           user supplied argument to visitor function.
+ *
+ * @return              number of CPIO headers visited.
+ */
+int
+cpio_visit(
+    const uint8_t*         cpio_base,
+    size_t                 cpio_bytes,
+    cpio_visitor_t         cpio_visit_fn,
+    cpio_generic_header_t* g,
+    void*                  arg
+);
+
 #endif // __CPIOBIN_H__
diff --git a/include/dmalloc/dmalloc.h b/include/dmalloc/dmalloc.h
new file mode 100644 (file)
index 0000000..0f3cc49
--- /dev/null
@@ -0,0 +1,61 @@
+#ifndef __DMALLOC_H__
+#define __DMALLOC_H__
+
+/*
+  malloc(size_t n)
+  Returns a pointer to a newly allocated chunk of at least n bytes, or
+  null if no space is available, in which case errno is set to ENOMEM
+  on ANSI C systems.
+
+  If n is zero, malloc returns a minimum-sized chunk. (The minimum
+  size is 16 bytes on most 32bit systems, and 32 bytes on 64bit
+  systems.)  Note that size_t is an unsigned type, so calls with
+  arguments that would be negative if signed are interpreted as
+  requests for huge amounts of space, which will often fail. The
+  maximum supported value of n differs across systems, but is in all
+  cases less than the maximum representable value of a size_t.
+*/
+void* dlmalloc(size_t);
+
+/*
+  free(void* p)
+  Releases the chunk of memory pointed to by p, that had been previously
+  allocated using malloc or a related routine such as realloc.
+  It has no effect if p is null. If p was not malloced or already
+  freed, free(p) will by default cause the current program to abort.
+*/
+void  dlfree(void*);
+
+/*
+  calloc(size_t n_elements, size_t element_size);
+  Returns a pointer to n_elements * element_size bytes, with all locations
+  set to zero.
+*/
+void* dlcalloc(size_t, size_t);
+
+/*
+  realloc(void* p, size_t n)
+  Returns a pointer to a chunk of size n that contains the same data
+  as does chunk p up to the minimum of (n, p's size) bytes, or null
+  if no space is available.
+
+  The returned pointer may or may not be the same as p. The algorithm
+  prefers extending p in most cases when possible, otherwise it
+  employs the equivalent of a malloc-copy-free sequence.
+
+  If p is null, realloc is equivalent to malloc.
+
+  If space is not available, realloc returns null, errno is set (if on
+  ANSI) and p is NOT freed.
+
+  if n is for fewer bytes than already held by p, the newly unused
+  space is lopped off and freed if possible.  realloc with a size
+  argument of zero (re)allocates a minimum-sized chunk.
+
+  The old unix realloc convention of allowing the last-free'd chunk
+  to be used as an argument to realloc is not supported.
+*/
+
+void* dlrealloc(void*, size_t);
+
+#endif
index 98003d6..58ae3b5 100644 (file)
 #include <barrelfish/bulk_transfer.h>
 #include <contmng/contmng.h>
 #include <if/ether_defs.h>
+#include <barrelfish/net_constants.h>
 
 /*****************************************************************
  * Constants:
  *****************************************************************/
 #define RECEIVE_BUFFER_SIZE 2048 // user provided memory
 
-#ifdef CONFIG_QEMU_NETWORK
-#define RECEIVE_BUFFERS 512
-#define TRANSMIT_BUFFERS 512 //< Number of transmit descriptors
-                              //< (must be multiple of 8)
-#else // CONFIG_QEMU_NETWORK
-#define RECEIVE_BUFFERS 2048
-#define TRANSMIT_BUFFERS 2048 //< Number of transmit descriptors
-                              //< (must be multiple of 8)
-#endif // CONFIG_QEMU_NETWORK
 
 
 #define MAX_NR_TRANSMIT_PBUFS 80
@@ -47,6 +39,7 @@
 
 struct filter {
     uint64_t filter_id;
+    uint64_t filter_type;
     uint8_t *data;
     int32_t len;
     struct buffer_descriptor *buffer;
@@ -118,7 +111,9 @@ struct client_closure {
     /* Following two are used by packet transmit logic */
     uintptr_t nr_transmit_pbufs; /*< how many pbufs belong to the packet to
                                         transmit now? */
-    uintptr_t rtpbuf; ///< how many pbufs have we received so far?
+    /* FIXME: following should be a number */
+//    uintptr_t rtpbuf; ///< how many pbufs have we received so far?
+    uint16_t rtpbuf; ///< how many pbufs have we received so far?
     struct tx_pbuf pbuf[MAX_NR_TRANSMIT_PBUFS];
     uint64_t tx_private_mem_v;
     uint64_t tx_private_mem_p;
diff --git a/include/fcntl.h b/include/fcntl.h
new file mode 100644 (file)
index 0000000..1572ca4
--- /dev/null
@@ -0,0 +1,280 @@
+/*-
+ * Copyright (c) 1983, 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)fcntl.h     8.3 (Berkeley) 1/21/94
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_FCNTL_H_
+#define        _SYS_FCNTL_H_
+
+/*
+ * This file includes the definitions for open and fcntl
+ * described by POSIX for <fcntl.h>; it also includes
+ * related kernel definitions.
+ */
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#ifndef _MODE_T_DECLARED
+typedef        __mode_t        mode_t;
+#define        _MODE_T_DECLARED
+#endif
+
+#ifndef _OFF_T_DECLARED
+typedef        __off_t         off_t;
+#define        _OFF_T_DECLARED
+#endif
+
+#ifndef _PID_T_DECLARED
+typedef        __pid_t         pid_t;
+#define        _PID_T_DECLARED
+#endif
+
+/*
+ * File status flags: these are used by open(2), fcntl(2).
+ * They are also used (indirectly) in the kernel file structure f_flags,
+ * which is a superset of the open/fcntl flags.  Open flags and f_flags
+ * are inter-convertible using OFLAGS(fflags) and FFLAGS(oflags).
+ * Open/fcntl flags begin with O_; kernel-internal flags begin with F.
+ */
+/* open-only flags */
+#define        O_RDONLY        0x0000          /* open for reading only */
+#define        O_WRONLY        0x0001          /* open for writing only */
+#define        O_RDWR          0x0002          /* open for reading and writing */
+#define        O_ACCMODE       0x0003          /* mask for above modes */
+
+/*
+ * Kernel encoding of open mode; separate read and write bits that are
+ * independently testable: 1 greater than the above.
+ *
+ * XXX
+ * FREAD and FWRITE are excluded from the #ifdef _KERNEL so that TIOCFLUSH,
+ * which was documented to use FREAD/FWRITE, continues to work.
+ */
+#define O_CREAT    00100
+#define O_EXCL     00200
+#define O_NOCTTY   00400
+#define O_TRUNC    01000       
+#define O_APPEND   02000
+#define O_NONBLOCK 04000
+#define O_SYNC    010000
+#define O_FSYNC          O_SYNC
+#define O_ASYNC          020000
+
+#if __BSD_VISIBLE
+/* Attempt to bypass buffer cache */
+#define O_DIRECT       0x00010000
+#endif
+
+/* Defined by POSIX Extended API Set Part 2 */
+#if __BSD_VISIBLE
+#define        O_DIRECTORY     0x00020000      /* Fail if not directory */
+#define        O_EXEC          0x00040000      /* Open for execute only */
+#endif
+#ifdef _KERNEL
+#define        FEXEC           O_EXEC
+#endif
+
+/* Defined by POSIX 1003.1-2008; BSD default, but reserve for future use. */
+#if __POSIX_VISIBLE >= 200809
+#define        O_TTY_INIT      0x00080000      /* Restore default termios attributes */
+#endif
+
+/*
+ * XXX missing O_DSYNC, O_RSYNC.
+ */
+
+#ifdef _KERNEL
+/* convert from open() flags to/from fflags; convert O_RD/WR to FREAD/FWRITE */
+#define        FFLAGS(oflags)  ((oflags) + 1)
+#define        OFLAGS(fflags)  ((fflags) - 1)
+
+/* bits to save after open */
+#define        FMASK   (FREAD|FWRITE|FAPPEND|FASYNC|FFSYNC|FNONBLOCK|O_DIRECT|FEXEC)
+/* bits settable by fcntl(F_SETFL, ...) */
+#define        FCNTLFLAGS      (FAPPEND|FASYNC|FFSYNC|FNONBLOCK|FRDAHEAD|O_DIRECT)
+
+#if defined(COMPAT_FREEBSD7) || defined(COMPAT_FREEBSD6) || \
+    defined(COMPAT_FREEBSD5) || defined(COMPAT_FREEBSD4)
+/*
+ * Set by shm_open(3) in older libc's to get automatic MAP_ASYNC
+ * behavior for POSIX shared memory objects (which are otherwise
+ * implemented as plain files).
+ */
+#define        FPOSIXSHM       O_NOFOLLOW
+#undef FCNTLFLAGS
+#define        FCNTLFLAGS      (FAPPEND|FASYNC|FFSYNC|FNONBLOCK|FPOSIXSHM|FRDAHEAD| \
+                        O_DIRECT)
+#endif
+#endif
+
+/*
+ * The O_* flags used to have only F* names, which were used in the kernel
+ * and by fcntl.  We retain the F* names for the kernel f_flag field
+ * and for backward compatibility for fcntl.  These flags are deprecated.
+ */
+#if __BSD_VISIBLE
+#define        FAPPEND         O_APPEND        /* kernel/compat */
+#define        FASYNC          O_ASYNC         /* kernel/compat */
+#define        FFSYNC          O_FSYNC         /* kernel */
+#define        FNONBLOCK       O_NONBLOCK      /* kernel */
+#define        FNDELAY         O_NONBLOCK      /* compat */
+#define        O_NDELAY        O_NONBLOCK      /* compat */
+#endif
+
+/*
+ * We are out of bits in f_flag (which is a short).  However,
+ * the flag bits not set in FMASK are only meaningful in the
+ * initial open syscall.  Those bits can thus be given a
+ * different meaning for fcntl(2).
+ */
+#if __BSD_VISIBLE
+/* Read ahead */
+#define        FRDAHEAD        O_CREAT
+#endif
+
+/* Defined by POSIX Extended API Set Part 2 */
+#if __BSD_VISIBLE
+/*
+ * Magic value that specify the use of the current working directory
+ * to determine the target of relative file paths in the openat() and
+ * similar syscalls.
+ */
+#define        AT_FDCWD                -100
+
+/*
+ * Miscellaneous flags for the *at() syscalls.
+ */
+#define        AT_EACCESS              0x100   /* Check access using effective user and group ID */
+#define        AT_SYMLINK_NOFOLLOW     0x200   /* Do not follow symbolic links */
+#define        AT_SYMLINK_FOLLOW       0x400   /* Follow symbolic link */
+#define        AT_REMOVEDIR            0x800   /* Remove directory instead of file */
+#endif
+
+/*
+ * Constants used for fcntl(2)
+ */
+
+/* command values */
+#define        F_DUPFD         0               /* duplicate file descriptor */
+#define        F_GETFD         1               /* get file descriptor flags */
+#define        F_SETFD         2               /* set file descriptor flags */
+#define        F_GETFL         3               /* get file status flags */
+#define        F_SETFL         4               /* set file status flags */
+#if __BSD_VISIBLE || __XSI_VISIBLE || __POSIX_VISIBLE >= 200112
+#define        F_GETOWN        5               /* get SIGIO/SIGURG proc/pgrp */
+#define F_SETOWN       6               /* set SIGIO/SIGURG proc/pgrp */
+#endif
+#define        F_OGETLK        7               /* get record locking information */
+#define        F_OSETLK        8               /* set record locking information */
+#define        F_OSETLKW       9               /* F_SETLK; wait if blocked */
+#define        F_DUP2FD        10              /* duplicate file descriptor to arg */
+#define        F_GETLK         11              /* get record locking information */
+#define        F_SETLK         12              /* set record locking information */
+#define        F_SETLKW        13              /* F_SETLK; wait if blocked */
+#define        F_SETLK_REMOTE  14              /* debugging support for remote locks */
+#define        F_READAHEAD     15              /* read ahead */
+#define        F_RDAHEAD       16              /* Darwin compatible read ahead */
+
+/* file descriptor flags (F_GETFD, F_SETFD) */
+#define        FD_CLOEXEC      1               /* close-on-exec flag */
+
+/* record locking flags (F_GETLK, F_SETLK, F_SETLKW) */
+#define        F_RDLCK         1               /* shared or read lock */
+#define        F_UNLCK         2               /* unlock */
+#define        F_WRLCK         3               /* exclusive or write lock */
+#define        F_UNLCKSYS      4               /* purge locks for a given system ID */ 
+#define        F_CANCEL        5               /* cancel an async lock request */
+#ifdef _KERNEL
+#define        F_WAIT          0x010           /* Wait until lock is granted */
+#define        F_FLOCK         0x020           /* Use flock(2) semantics for lock */
+#define        F_POSIX         0x040           /* Use POSIX semantics for lock */
+#define        F_REMOTE        0x080           /* Lock owner is remote NFS client */
+#define F_NOINTR       0x100           /* Ignore signals when waiting */
+#endif
+
+/*
+ * Advisory file segment locking data type -
+ * information passed to system by user
+ */
+struct flock {
+       off_t   l_start;        /* starting offset */
+       off_t   l_len;          /* len = 0 means until end of file */
+       pid_t   l_pid;          /* lock owner */
+       short   l_type;         /* lock type: read/write, etc. */
+       short   l_whence;       /* type of l_start */
+       int     l_sysid;        /* remote system id or zero for local */
+};
+
+/*
+ * Old advisory file segment locking data type,
+ * before adding l_sysid.
+ */
+struct oflock {
+       off_t   l_start;        /* starting offset */
+       off_t   l_len;          /* len = 0 means until end of file */
+       pid_t   l_pid;          /* lock owner */
+       short   l_type;         /* lock type: read/write, etc. */
+       short   l_whence;       /* type of l_start */
+};
+
+
+#if __BSD_VISIBLE
+/* lock operations for flock(2) */
+#define        LOCK_SH         0x01            /* shared file lock */
+#define        LOCK_EX         0x02            /* exclusive file lock */
+#define        LOCK_NB         0x04            /* don't block when locking */
+#define        LOCK_UN         0x08            /* unlock file */
+#endif
+
+/*
+ * XXX missing posix_fadvise() and posix_fallocate(), and POSIX_FADV_* macros.
+ */
+
+#ifndef _KERNEL
+__BEGIN_DECLS
+int open(const char*pathname, int flags, ...);
+int creat (char * file, int mode);
+int    fcntl(int, int, ...);
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200809
+int    openat(int, const char *, int, ...);
+#endif
+#if __BSD_VISIBLE
+int    flock(int, int);
+#endif
+__END_DECLS
+#endif
+
+#endif /* !_SYS_FCNTL_H_ */
index 9ac98ae..36548f0 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2010, ETH Zurich.
+ * Copyright (c) 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -47,6 +47,8 @@ void flounder_support_monitor_mutex_enqueue(struct monitor_binding *mb,
                                             struct event_queue_node *qn,
                                             struct event_closure cl);
 void flounder_support_monitor_mutex_unlock(struct monitor_binding *mb);
+void flounder_support_migrate_notify(struct waitset_chanstate *chan,
+                                     struct waitset *new_ws);
 
 #if defined(FLOUNDER_DEBUG)
 # include <barrelfish_kpi/dispatcher_shared.h>
diff --git a/include/grp.h b/include/grp.h
new file mode 100644 (file)
index 0000000..2b9f73f
--- /dev/null
@@ -0,0 +1,89 @@
+/*-
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)grp.h       8.2 (Berkeley) 1/21/94
+ * $FreeBSD$
+ */
+
+#ifndef _GRP_H_
+#define        _GRP_H_
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#define        _PATH_GROUP             "/etc/group"
+
+#ifndef _GID_T_DECLARED
+typedef        __gid_t         gid_t;
+#define        _GID_T_DECLARED
+#endif
+
+#ifndef _SIZE_T_DECLARED
+typedef __size_t       size_t;
+#define _SIZE_T_DECLARED
+#endif
+
+struct group {
+       char    *gr_name;               /* group name */
+       char    *gr_passwd;             /* group password */
+       gid_t   gr_gid;                 /* group id */
+       char    **gr_mem;               /* group members */
+};
+
+__BEGIN_DECLS
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE
+void            endgrent(void);
+struct group   *getgrent(void);
+#endif
+struct group   *getgrgid(gid_t);
+struct group   *getgrnam(const char *);
+#if __BSD_VISIBLE
+const char     *group_from_gid(gid_t, int);
+#endif
+#if __BSD_VISIBLE || __XSI_VISIBLE
+/* XXX IEEE Std 1003.1, 2003 specifies `void setgrent(void)' */
+int             setgrent(void);
+#endif
+#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE
+int             getgrgid_r(gid_t, struct group *, char *, size_t,
+                   struct group **);
+int             getgrnam_r(const char *, struct group *, char *, size_t,
+                   struct group **);
+#endif
+#if __BSD_VISIBLE
+int             getgrent_r(struct group *, char *, size_t, struct group **);
+int             setgroupent(int);
+#endif
+__END_DECLS
+
+#endif /* !_GRP_H_ */
diff --git a/include/hashtable/dictionary.h b/include/hashtable/dictionary.h
new file mode 100644 (file)
index 0000000..7fea33c
--- /dev/null
@@ -0,0 +1,37 @@
+/**
+ * \file
+ * \brief Dictionary type
+ */
+
+/*
+ * Copyright (c) 2008, 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+#ifndef DICTIONARY_H_
+#define DICTIONARY_H_
+
+#include <barrelfish/barrelfish.h>
+
+typedef enum uint8_t {
+    TYPE_STRING = 1,
+    TYPE_WORD,
+    TYPE_OPAQUE,
+    TYPE_CAPABILITY,
+} ENTRY_TYPE;
+
+/**
+ * \brief dictionary_t is the abstract type of
+ *   datastructures that are able to store key/value pairs
+ */
+struct dictionary {
+    int (*put_word)(struct dictionary*, char*, size_t, uintptr_t);
+    ENTRY_TYPE (*get)(struct dictionary*, char*, size_t, void**);
+    int (*size)(struct dictionary*);
+    int (*remove)(struct dictionary*, char*, size_t);
+};
+
+#endif /*DICTIONARY_H_*/
diff --git a/include/hashtable/hashtable.h b/include/hashtable/hashtable.h
new file mode 100644 (file)
index 0000000..30b5e3b
--- /dev/null
@@ -0,0 +1,62 @@
+/**
+ * \file
+ * \brief Hashtable headers
+ */
+
+/*
+ * Copyright (c) 2008, 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+#ifndef HASHTABLE_H_
+#define HASHTABLE_H_
+
+#include <hashtable/dictionary.h>
+#include <stdio.h>
+
+/**
+ * \brief an entry of a hashtable
+ */
+struct _ht_entry {
+    void* key;
+    size_t key_len;
+    void* value;
+    struct capref capvalue;
+    ENTRY_TYPE type;
+    int hash_value;
+    struct _ht_entry *next;
+};
+
+/**
+ * \brief hashtable
+ */
+struct hashtable {
+    struct dictionary d;
+    int table_length;
+    int entry_count;
+    struct _ht_entry **entries;
+    int threshold;
+    int capacity;
+    int load_factor;
+};
+
+/**
+ * \brief create an empty hashtable with a given capacity and load factor
+ * \param capacity the capacity
+ * \param the load factor
+ * \return an empty hashtable.
+ */
+struct hashtable* create_hashtable2(int capacity, int loadFactor);
+
+/**
+ * \brief create an empty hashtable with default capacity and load factor
+ * \return an empty hashtable
+ */
+struct hashtable* create_hashtable(void);
+
+void print_hashtable(FILE *stream, struct hashtable *ht);
+
+#endif /*HASHTABLE_H_*/
diff --git a/include/hashtable/multimap.h b/include/hashtable/multimap.h
new file mode 100644 (file)
index 0000000..4b8783c
--- /dev/null
@@ -0,0 +1,30 @@
+/**
+ * \file
+ * \brief multimap implementation
+ */
+
+/*
+ * Copyright (c) 2009, 2011 ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef MULTIMAP_H_
+#define MULTIMAP_H_
+
+#include <hashtable/hashtable.h>
+
+struct multimap {
+    struct hashtable h;
+    int (*put)(struct multimap*, char*, void*);
+    int (*remove)(struct multimap*, char*, void*);
+    int (*get_first)(struct multimap*, char*, void**);
+    int (*get_all)(struct multimap*, char*, void**, int);
+};
+
+struct multimap* create_multimap(void);
+
+#endif /* MULTIMAP_H_ */
index 9fa5dec..887df51 100644 (file)
  * by the laws in force in New South Wales, Australia.
  */
 
+#ifndef _LOCALE_H_
+#define _LOCALE_H_
+
 #include <stddef.h>
 
 struct lconv {
        char *decimal_point;
        char *thousands_sep;
        char *grouping;
-       char *mon_deciaml_point;
-       char *mon_thouasands_sep;
+       char *mon_decimal_point;
+       char *mon_thousands_sep;
        char *mon_grouping;
        char *positive_sign;
        char *negative_sign;
@@ -119,3 +122,5 @@ struct lconv *localeconv(void);
 // For POSIX compatibility
 // From: The Open Group Base Specifications Issue 7, IEEE Std 1003.1-2008
 typedef void *locale_t;
+
+#endif
index f6b1f74..d17f985 100644 (file)
@@ -183,6 +183,13 @@ err_t             netconn_getaddr (struct netconn *conn,
 err_t             netconn_bind    (struct netconn *conn,
                                    struct ip_addr *addr,
                                    u16_t port);
+
+err_t             netconn_redirect(struct netconn *conn, 
+                                   struct ip_addr *local_ip, 
+                                   u16_t local_port,
+                                   struct ip_addr *remote_ip, 
+                                   u16_t remote_port);
+
 err_t             netconn_connect (struct netconn *conn,
                                    struct ip_addr *addr,
                                    u16_t port);
index 4272d77..8a0edce 100644 (file)
@@ -100,6 +100,14 @@ struct api_msg_msg {
       u8_t backlog;
     } lb;
 #endif /* TCP_LISTEN_BACKLOG */
+      // IK
+    struct {
+      struct ip_addr *local_ip;
+      u16_t local_port;
+      struct ip_addr *remote_ip;
+      u16_t remote_port;
+    } red;
+
   } msg;
 };
 
@@ -134,6 +142,7 @@ struct dns_api_msg {
 void do_newconn         ( struct api_msg_msg *msg);
 void do_delconn         ( struct api_msg_msg *msg);
 void do_bind            ( struct api_msg_msg *msg);
+void do_redirect        ( struct api_msg_msg *msg);
 void do_connect         ( struct api_msg_msg *msg);
 void do_disconnect      ( struct api_msg_msg *msg);
 void do_listen          ( struct api_msg_msg *msg);
index 825dba6..87e6f04 100644 (file)
@@ -20,7 +20,7 @@ extern "C" {
 /** period (in milliseconds) of the application calling dhcp_coarse_tmr() */
 #define DHCP_COARSE_TIMER_MSECS (DHCP_COARSE_TIMER_SECS * 1000UL)
 /** period (in milliseconds) of the application calling dhcp_fine_tmr() */
-#define DHCP_FINE_TIMER_MSECS 500 
+#define DHCP_FINE_TIMER_MSECS 500
 
 struct dhcp
 {
index 561ea48..f60db07 100644 (file)
@@ -85,6 +85,7 @@ extern const char *lwip_strerr(err_t err);
 #endif
 
 #include <errors/errno.h>
+#include <errno.h>
 errval_t lwip_err_to_errval(err_t e);
 
 #endif /* __LWIP_ERR_H__ */
index 0f7b2ec..97600bd 100644 (file)
 #define EAI_SERVICE     201
 #define EAI_FAIL        202
 #define EAI_MEMORY      203
+#define EAI_FAMILY      204
 
 #define HOST_NOT_FOUND  210
 #define NO_DATA         211
 #define NO_RECOVERY     212
 #define TRY_AGAIN       213
+#define EAI_AGAIN      TRY_AGAIN
 #endif /* LWIP_DNS_API_DEFINE_ERRORS */
 
 #if LWIP_DNS_API_DECLARE_STRUCTS
index caaf29c..c44a90d 100644 (file)
  * (requires the LWIP_TCP option)
  */
 #ifndef MEMP_NUM_TCP_PCB_LISTEN
-#define MEMP_NUM_TCP_PCB_LISTEN         8
+#define MEMP_NUM_TCP_PCB_LISTEN         18
 #endif
 
 /**
  * (requires NO_SYS==0)
  */
 #ifndef MEMP_NUM_SYS_TIMEOUT
-#define MEMP_NUM_SYS_TIMEOUT            3
+#define MEMP_NUM_SYS_TIMEOUT            8
 #endif
 
 /**
  * (only needed if you use the sequential API, like api_lib.c)
  */
 #ifndef MEMP_NUM_NETBUF
-#define MEMP_NUM_NETBUF                 2
+#define MEMP_NUM_NETBUF                 12
 #endif
 
 /**
  * (only needed if you use the sequential API, like api_lib.c)
  */
 #ifndef MEMP_NUM_NETCONN
-#define MEMP_NUM_NETCONN                4
+#define MEMP_NUM_NETCONN                24
 #endif
 
 /**
  * (only needed if you use tcpip.c)
  */
 #ifndef MEMP_NUM_TCPIP_MSG_API
-#define MEMP_NUM_TCPIP_MSG_API          8
+#define MEMP_NUM_TCPIP_MSG_API          38
 #endif
 
 /**
  * (only needed if you use tcpip.c)
  */
 #ifndef MEMP_NUM_TCPIP_MSG_INPKT
-#define MEMP_NUM_TCPIP_MSG_INPKT        8
+#define MEMP_NUM_TCPIP_MSG_INPKT        38
 #endif
 
 /**
  * debug messages of certain types.
  */
 #ifndef LWIP_DBG_TYPES_ON
-#define LWIP_DBG_TYPES_ON               LWIP_DBG_ON
+#define LWIP_DBG_TYPES_ON               LWIP_DBG_OFF
 #endif
 
 /**
diff --git a/include/lwip/sock_serialise.h b/include/lwip/sock_serialise.h
new file mode 100644 (file)
index 0000000..66246d9
--- /dev/null
@@ -0,0 +1,23 @@
+#ifndef SOCK_SERIALISE_H
+#define SOCK_SERIALISE_H
+
+#include "lwip/sockets.h"
+#include "lwip/tcp.h"
+#include "lwip/api.h"
+
+// IK
+// ports are in host order
+struct lwip_sockinfo {
+    struct ip_addr local_ip;
+    u16_t local_port;
+    struct ip_addr remote_ip;
+    u16_t remote_port;
+    struct tcp_pcb tcp_state;
+    struct netconn netconn_state;
+
+};
+
+int lwip_serialise_sock(int s, struct lwip_sockinfo *si);
+int lwip_deserialise_sock(int s, struct lwip_sockinfo *si);
+
+#endif
index 7b52e15..8e85186 100644 (file)
@@ -39,6 +39,7 @@
 #if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */
 
 #include <stddef.h> /* for size_t */
+#include <fcntl.h>
 
 #include "lwip/ip_addr.h"
 #include "lwip/inet.h"
@@ -76,14 +77,14 @@ struct sockaddr {
  */
 #define  SO_DEBUG       0x0001 /* Unimplemented: turn on debugging info recording */
 #define  SO_ACCEPTCONN  0x0002 /* socket has had listen() */
-#define  SO_REUSEADDR   0x0004 /* Unimplemented: allow local address reuse */
+//#define  SO_REUSEADDR   0x0004 /* Unimplemented: allow local address reuse */
 #define  SO_KEEPALIVE   0x0008 /* keep connections alive */
 #define  SO_DONTROUTE   0x0010 /* Unimplemented: just use interface addresses */
 #define  SO_BROADCAST   0x0020 /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */
 #define  SO_USELOOPBACK 0x0040 /* Unimplemented: bypass hardware when possible */
 #define  SO_LINGER      0x0080 /* linger on close if data present */
 #define  SO_OOBINLINE   0x0100 /* Unimplemented: leave received OOB data in line */
-#define  SO_REUSEPORT   0x0200 /* Unimplemented: allow local address & port reuse */
+//#define  SO_REUSEPORT   0x0200 /* Unimplemented: allow local address & port reuse */
 
 #define SO_DONTLINGER   ((int)(~SO_LINGER))
 
@@ -286,7 +287,7 @@ typedef struct ip_mreq {
 /** LWIP_TIMEVAL_PRIVATE: if you want to use the struct timeval provided
  * by your system, set this to 0 and include <sys/time.h> in cc.h */ 
 #ifndef LWIP_TIMEVAL_PRIVATE
-#define LWIP_TIMEVAL_PRIVATE 1
+#define LWIP_TIMEVAL_PRIVATE 0
 #endif
 
 #if LWIP_TIMEVAL_PRIVATE
@@ -354,4 +355,5 @@ int lwip_ioctl(int s, long cmd, void *argp);
 
 #endif /* LWIP_SOCKET */
 
+
 #endif /* __LWIP_SOCKETS_H__ */
index 0cc84dd..a82359f 100644 (file)
@@ -240,4 +240,9 @@ void sys_arch_unprotect(sys_prot_t pval);
 }
 #endif
 
+extern struct thread_mutex *lwip_mutex;
+
+void lwip_mutex_lock(void);
+void lwip_mutex_unlock(void);
+
 #endif /* __LWIP_SYS_H__ */
index 8f6b9d3..e2a1dea 100644 (file)
@@ -88,6 +88,11 @@ void             tcp_err     (struct tcp_pcb *pcb,
 void             tcp_recved  (struct tcp_pcb *pcb, u16_t len);
 err_t            tcp_bind    (struct tcp_pcb *pcb, struct ip_addr *ipaddr,
                               u16_t port);
+err_t           tcp_redirect(struct tcp_pcb *pcb, 
+                              struct ip_addr *local_ip, 
+                              u16_t local_port,
+                              struct ip_addr *remote_ip, 
+                              u16_t remote_port);
 err_t            tcp_connect (struct tcp_pcb *pcb, struct ip_addr *ipaddr,
                               u16_t port, err_t (* connected)(void *arg,
                               struct tcp_pcb *tpcb,
index 75393ee..6775e4f 100644 (file)
@@ -65,7 +65,7 @@ extern sys_sem_t lock_tcpip_core;
 #define TCPIP_NETIFAPI_ACK(m) sys_sem_signal(m->sem)
 #endif /* LWIP_TCPIP_CORE_LOCKING */
 
-void tcpip_init(void (* tcpip_init_done)(void *), void *arg);
+void tcpip_init(char *card_name, void (* tcpip_init_done)(void *), void *arg);
 
 #if LWIP_NETCONN
 err_t tcpip_apimsg(struct api_msg *apimsg);
index 2414758..4ca638c 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
 #ifndef LWIPOPTS_H
 #define LWIPOPTS_H
 
+#include <barrelfish/net_constants.h>
 /// Build DHCP client
 #define LWIP_DHCP               1
 
-/// We do not want LWIP to provide POSIX errno
-#undef LWIP_PROVIDE_ERRNO
-
-/// No operating system support for locks, semaphores, mailboxes or timers
-#define NO_SYS                  1
+/// Build DNS client
+#define LWIP_DNS               1
 
-/// Don't want BSD sockets
-#define LWIP_SOCKET             0
+/// Don't want lwip POSIX socket wrappers
+#define LWIP_POSIX_SOCKETS_IO_NAMES     0
 
-/// Don't want Netconn API
-#define LWIP_NETCONN            0
+/// We do not want LWIP to provide POSIX errno
+#undef LWIP_PROVIDE_ERRNO
 
-/// Disable raw interface code
-//#define LWIP_RAW                0
+/// Don't want socket functions overriden by lwIP. We provide our own.
+#define LWIP_COMPAT_SOCKETS     0
 
 /// Use malloc() from libc
 //#define MEM_LIBC_MALLOC         1
 /// Disable locks (we lock the whole stack)
 #define SYS_LIGHTWEIGHT_PROT    0
 
-/// Size of (static) heap memory
-#define MEM_SIZE                (60*1024*1024)
 
 /// Number of simultaneously active TCP connections
 #define MEMP_NUM_TCP_PCB        200
 
-#ifdef CONFIG_QEMU_NETWORK
-/// Number of PBUF structs available
-#define MEMP_NUM_PBUF           1024
-/// Number of PBUF buffers available
-#define PBUF_POOL_SIZE          1024
-#else // CONFIG_QEMU_NETWORK
-/// Number of PBUF structs available
-#define MEMP_NUM_PBUF           16384
-/// Number of PBUF buffers available
-#define PBUF_POOL_SIZE          16384
-#endif // CONFIG_QEMU_NETWORK
 
 
-/// the size of the pool
-#define PBUF_POOL_BUFSIZE       (4 * 2048)
-
 /// Number of TCP segments
 #define MEMP_NUM_TCP_SEG        512
 
 #define TCP_SND_QUEUELEN       (16 * (TCP_SND_BUF/TCP_MSS))
 
 /// Enable debugging
-#define LWIP_DEBUG              1
+#define LWIP_DEBUG              0
+
+/// Enable have loopif (localhost hostname translation)
+#define LWIP_HAVE_LOOPIF 1
+
 /* Place to control the LWIP debugging.
  Enable debugging of these subsystems */
 
-/* #define ETHARP_DEBUG    LWIP_DBG_ON */
-/* #define NETIF_DEBUG     LWIP_DBG_ON */
-/* #define PBUF_DEBUG      LWIP_DBG_ON */
-/* #define DHCP_DEBUG      LWIP_DBG_ON */
-/* #define UDP_DEBUG       LWIP_DBG_ON */
-/* #define IP_DEBUG        LWIP_DBG_ON */
-/* #define TCP_DEBUG       LWIP_DBG_ON */
-/* #define TCP_INPUT_DEBUG LWIP_DBG_ON */
+/* #define ETHARP_DEBUG     LWIP_DBG_ON */
+/* #define NETIF_DEBUG      LWIP_DBG_ON */
+/* #define PBUF_DEBUG       LWIP_DBG_ON */
+/* #define DHCP_DEBUG       LWIP_DBG_ON */
+/* #define UDP_DEBUG        LWIP_DBG_ON */
+/* #define IP_DEBUG         LWIP_DBG_ON */
+/* #define TCP_DEBUG        LWIP_DBG_ON */
+/* #define TCPIP_DEBUG      LWIP_DBG_ON */
+/* #define TCP_INPUT_DEBUG  LWIP_DBG_ON */
 /* #define TCP_OUTPUT_DEBUG LWIP_DBG_ON */
-
+/* #define SOCKETS_DEBUG    LWIP_DBG_ON */
 
 #ifndef CHECKSUM_GEN_IP
 #define CHECKSUM_GEN_IP                 1
index 6d0e3f5..4ecbdf1 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2008, ETH Zurich.
+ * Copyright (c) 2008, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -53,13 +53,15 @@ struct mm {
     enum objtype objtype;   ///< Type of capabilities stored
     uint8_t sizebits;       ///< Size of root node (in bits)
     uint8_t maxchildbits;   ///< Maximum number of children of every node (in bits)
+    bool delete_chunked;    ///< Delete chunked capabilities if true
 };
 
 void mm_debug_print(struct mmnode *mmnode, int space);
 errval_t mm_init(struct mm *mm, enum objtype objtype, genpaddr_t base,
                  uint8_t sizebits, uint8_t maxchildbits,
                  slab_refill_func_t slab_refill_func,
-                 slot_alloc_t slot_alloc_func, void *slot_alloc_inst);
+                 slot_alloc_t slot_alloc_func, void *slot_alloc_inst,
+                 bool delete_chunked);
 void mm_destroy(struct mm *mm);
 errval_t mm_add(struct mm *mm, struct capref cap, uint8_t sizebits,
                 genpaddr_t base);
@@ -70,7 +72,8 @@ errval_t mm_alloc_range(struct mm *mm, uint8_t sizebits, genpaddr_t minbase,
                         genpaddr_t *retbase);
 errval_t mm_realloc_range(struct mm *mm, uint8_t sizebits, genpaddr_t base,
                           struct capref *retcap);
-errval_t mm_free(struct mm *mm, genpaddr_t base, uint8_t sizebits);
+errval_t mm_free(struct mm *mm, struct capref cap, genpaddr_t base,
+                 uint8_t sizebits);
 
 /// Structure to record all information about a given memory region
 struct mem_cap {
diff --git a/include/netdb.h b/include/netdb.h
new file mode 100644 (file)
index 0000000..8247195
--- /dev/null
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+/* This file includes lwIP's netdb.h -- purely for compatibility */
+
+#ifndef NETDB_H
+#define NETDB_H
+
+#include <lwip/netdb.h>
+
+struct hostent *gethostbyname(const char *name);
+int getaddrinfo(const char *nodename,
+                const char *servname,
+                const struct addrinfo *hints,
+                struct addrinfo **res);
+void freeaddrinfo(struct addrinfo *ai);
+const char *gai_strerror(int ecode);
+
+#endif
diff --git a/include/netinet/in.h b/include/netinet/in.h
new file mode 100644 (file)
index 0000000..be38979
--- /dev/null
@@ -0,0 +1,6 @@
+#ifndef IN_H
+#define IN_H
+
+#include <lwip/sockets.h>
+
+#endif
index 6d7a57e..23e7358 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2008, 2009, ETH Zurich.
+ * Copyright (c) 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -176,6 +176,19 @@ typedef void (*nfs_create_callback_t)(void *arg, struct nfs_client *client,
 typedef void (*nfs_mkdir_callback_t)(void *arg, struct nfs_client *client,
                                      MKDIR3res *result);
 
+/**
+ * \brief Callback function for remove operation
+ *
+ * \param arg Opaque argument pointer, as provided to nfs_remove()
+ * \param client NFS client instance
+ * \param result Result pointer, or NULL on error
+ *
+ * The memory referred to by #result, if any, is now the property of the callee,
+ * and must be freed by the appropriate XDR free operations.
+ */
+typedef void (*nfs_remove_callback_t)(void *arg, struct nfs_client *client,
+                                      REMOVE3res *result);
+
 struct nfs_client *nfs_mount(struct ip_addr server, const char *path,
                              nfs_mount_callback_t callback, void *cbarg);
 err_t nfs_getattr(struct nfs_client *client, struct nfs_fh3 fh,
@@ -203,6 +216,9 @@ err_t nfs_create(struct nfs_client *client, struct nfs_fh3 dir,
                  nfs_create_callback_t callback, void *cbarg);
 err_t nfs_mkdir(struct nfs_client *client, struct nfs_fh3 dir, const char *name,
                 sattr3 attributes, nfs_mkdir_callback_t callback, void *cbarg);
+err_t nfs_remove(struct nfs_client *client, struct nfs_fh3 dir,
+                 const char *name, nfs_remove_callback_t callback,
+                 void *cbarg);
 void nfs_destroy(struct nfs_client *client);
 
 void nfs_copyfh(struct nfs_fh3 *dest, struct nfs_fh3 src);
index 1a2e5bd..076f440 100644 (file)
@@ -46,9 +46,9 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <lwip/inet.h> /* for ntohl/htonl */
+#include <sys/types.h>
 
 /* nasty typedefs needed by RPC/XDR code */
-typedef unsigned int u_int;
 typedef int enum_t;
 typedef bool bool_t;
 
diff --git a/include/posixcompat.h b/include/posixcompat.h
new file mode 100644 (file)
index 0000000..40f9ec5
--- /dev/null
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef POSIXCOMPAT_H
+#define POSIXCOMPAT_H
+
+errval_t spawn_setup_fds(struct capref *frame, int rfd);
+errval_t posixcompat_unpack_fds(void);
+
+#endif
diff --git a/include/pwd.h b/include/pwd.h
new file mode 100644 (file)
index 0000000..34ab91f
--- /dev/null
@@ -0,0 +1,172 @@
+/*-
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)pwd.h       8.2 (Berkeley) 1/21/94
+ * $FreeBSD$
+ */
+
+#ifndef _PWD_H_
+#define        _PWD_H_
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+#include <time.h>
+
+#ifndef _GID_T_DECLARED
+typedef        __gid_t         gid_t;
+#define        _GID_T_DECLARED
+#endif
+
+/* #ifndef _TIME_T_DECLARED */
+/* typedef     __time_t        time_t; */
+/* #define     _TIME_T_DECLARED */
+/* #endif */
+
+#ifndef _UID_T_DECLARED
+typedef        __uid_t         uid_t;
+#define        _UID_T_DECLARED
+#endif
+
+/* #ifndef _SIZE_T_DECLARED */
+/* typedef __size_t    size_t; */
+/* #define _SIZE_T_DECLARED */
+/* #endif */
+
+#define _PATH_PWD              "/etc"
+#define        _PATH_PASSWD            "/etc/passwd"
+#define        _PASSWD                 "passwd"
+#define        _PATH_MASTERPASSWD      "/etc/master.passwd"
+#define        _MASTERPASSWD           "master.passwd"
+
+#define        _PATH_MP_DB             "/etc/pwd.db"
+#define        _MP_DB                  "pwd.db"
+#define        _PATH_SMP_DB            "/etc/spwd.db"
+#define        _SMP_DB                 "spwd.db"
+
+#define        _PATH_PWD_MKDB          "/usr/sbin/pwd_mkdb"
+
+/* Historically, the keys in _PATH_MP_DB/_PATH_SMP_DB had the format
+ * `1 octet tag | key', where the tag is one of the _PW_KEY* values
+ * listed below.  These values happen to be ASCII digits.  Starting
+ * with FreeBSD 5.1, the tag is now still a single octet, but the
+ * upper 4 bits are interpreted as a version.  Pre-FreeBSD 5.1 format
+ * entries are version `3' -- this conveniently results in the same
+ * key values as before.  The new, architecture-independent entries
+ * are version `4'.
+ * As it happens, some applications read the database directly.
+ * (Bad app, no cookie!)  Thus, we leave the _PW_KEY* symbols at their
+ * old pre-FreeBSD 5.1 values so these apps still work.  Consequently
+ * we have to muck around a bit more to get the correct, versioned
+ * tag, and that is what the _PW_VERSIONED macro is about.
+ */
+
+#define _PW_VERSION_MASK       '\xF0'
+#define _PW_VERSIONED(x, v)    ((unsigned char)(((x) & 0xCF) | ((v)<<4)))
+
+#define        _PW_KEYBYNAME           '\x31'  /* stored by name */
+#define        _PW_KEYBYNUM            '\x32'  /* stored by entry in the "file" */
+#define        _PW_KEYBYUID            '\x33'  /* stored by uid */
+#define _PW_KEYYPENABLED       '\x34'  /* YP is enabled */
+#define        _PW_KEYYPBYNUM          '\x35'  /* special +@netgroup entries */
+
+/* The database also contains a key to indicate the format version of
+ * the entries therein.  There may be other, older versioned entries
+ * as well.
+ */
+#define _PWD_VERSION_KEY       "\xFF" "VERSION"
+#define _PWD_CURRENT_VERSION   '\x04'
+
+#define        _PASSWORD_EFMT1         '_'     /* extended encryption format */
+
+#define        _PASSWORD_LEN           128     /* max length, not counting NULL */
+
+struct passwd {
+       char    *pw_name;               /* user name */
+       char    *pw_passwd;             /* encrypted password */
+       uid_t   pw_uid;                 /* user uid */
+       gid_t   pw_gid;                 /* user gid */
+       time_t  pw_change;              /* password change time */
+       char    *pw_class;              /* user access class */
+       char    *pw_gecos;              /* Honeywell login info */
+       char    *pw_dir;                /* home directory */
+       char    *pw_shell;              /* default shell */
+       time_t  pw_expire;              /* account expiration */
+       int     pw_fields;              /* internal: fields filled in */
+};
+
+/* Mapping from fields to bits for pw_fields. */
+#define _PWF(x)                (1 << x)
+#define _PWF_NAME      _PWF(0)
+#define _PWF_PASSWD    _PWF(1)
+#define _PWF_UID       _PWF(2)
+#define _PWF_GID       _PWF(3)
+#define _PWF_CHANGE    _PWF(4)
+#define _PWF_CLASS     _PWF(5)
+#define _PWF_GECOS     _PWF(6)
+#define _PWF_DIR       _PWF(7)
+#define _PWF_SHELL     _PWF(8)
+#define _PWF_EXPIRE    _PWF(9)
+
+/* XXX These flags are bogus.  With nsswitch, there are many
+ * possible sources and they cannot be represented in a small integer.
+ */                           
+#define _PWF_SOURCE    0x3000
+#define _PWF_FILES     0x1000
+#define _PWF_NIS       0x2000
+#define _PWF_HESIOD    0x3000
+
+__BEGIN_DECLS
+struct passwd  *getpwnam(const char *);
+struct passwd  *getpwuid(uid_t);
+
+#if __XSI_VISIBLE >= 500
+void            endpwent(void);
+struct passwd  *getpwent(void);
+void            setpwent(void);
+#endif
+
+#if __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 500
+int             getpwnam_r(const char *, struct passwd *, char *, size_t,
+                   struct passwd **);
+int             getpwuid_r(uid_t, struct passwd *, char *, size_t,
+                   struct passwd **);
+#endif
+
+#if __BSD_VISIBLE
+int             getpwent_r(struct passwd *, char *, size_t, struct passwd **);
+int             setpassent(int);
+const char     *user_from_uid(uid_t, int);
+#endif
+__END_DECLS
+
+#endif /* !_PWD_H_ */
diff --git a/include/semaphore.h b/include/semaphore.h
new file mode 100644 (file)
index 0000000..f868863
--- /dev/null
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef SEMAPHORE_H
+#define SEMAPHORE_H
+
+#include <barrelfish/thread_sync.h>
+
+struct posix_semaphore {
+    int pshared;
+    struct thread_sem thread_sem;
+    uint32_t id;
+};
+
+typedef struct posix_semaphore sem_t;
+
+int sem_init(sem_t *sem, int pshared, unsigned int value);
+int sem_destroy(sem_t *sem);
+int sem_wait(sem_t *sem);
+int sem_trywait(sem_t *sem);
+int sem_post(sem_t *sem);
+
+#endif
index b045f7d..60f403f 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  */
 
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1991, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      @(#)signal.h    8.4 (Berkeley) 5/4/95
+ * $FreeBSD$
+ */
 
 #ifndef BARRELFISH_SIGNAL_H_
 #define BARRELFISH_SIGNAL_H_
 
-#define SIGINT          2
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+#include <sys/_sigset.h>
+
+#define SIGHUP          1       /* hangup */
+#define SIGINT          2       /* interrupt */
+#define SIGQUIT         3       /* quit */
+#define SIGILL          4       /* illegal instr. (not reset when caught) */
+#define SIGTRAP         5       /* trace trap (not reset when caught) */
+#define SIGABRT         6       /* abort() */
+#define SIGIOT          SIGABRT /* compatibility */
+#define SIGEMT          7       /* EMT instruction */
+#define SIGFPE          8       /* floating point exception */
+#define SIGKILL         9       /* kill (cannot be caught or ignored) */
+#define SIGBUS          10      /* bus error */
+#define SIGSEGV         11      /* segmentation violation */
+#define SIGSYS          12      /* non-existent system call invoked */
+#define SIGPIPE         13      /* write on a pipe with no one to read it */
+#define SIGALRM         14      /* alarm clock */
+#define SIGTERM         15      /* software termination signal from kill */
+#define SIGURG          16      /* urgent condition on IO channel */
+#define SIGSTOP         17      /* sendable stop signal not from tty */
+#define SIGTSTP         18      /* stop signal from tty */
+#define SIGCONT         19      /* continue a stopped process */
+#define SIGCHLD         20      /* to parent on child stop or exit */
+#define SIGTTIN         21      /* to readers pgrp upon background tty read */
+#define SIGTTOU         22      /* like TTIN if (tp->t_local&LTOSTOP) */
+#define SIGIO           23      /* input/output possible signal */
+#define SIGXCPU         24      /* exceeded CPU time limit */
+#define SIGXFSZ         25      /* exceeded file size limit */
+#define SIGVTALRM       26      /* virtual time alarm */
+#define SIGPROF         27      /* profiling time alarm */
+#define SIGWINCH        28      /* window size changes */
+#define SIGINFO         29      /* information request */
+#define SIGUSR1         30      /* user defined signal 1 */
+#define SIGUSR2         31      /* user defined signal 2 */
+#define SIGTHR          32      /* reserved by thread library. */
+#define SIGLWP          SIGTHR
+
+#define SIGRTMIN        65
+#define SIGRTMAX        126
+
+#define NSIG            32      /* number of old signals (counting 0) */
 
 #define SIG_ERR ((void *) -1)
 #define SIG_DFL ((void *) 0)
 #define SIG_IGN ((void *) 1)
+#define SIG_HOLD ((void *)3)
+
+#ifndef _PID_T_DECLARED
+typedef        __pid_t         pid_t;
+#define        _PID_T_DECLARED
+#endif
 
 typedef void (*signalhandler_t)(int);
 
+#ifndef _SIGSET_T_DECLARED
+#define _SIGSET_T_DECLARED
+typedef __sigset_t      sigset_t;
+#endif
+
+/*
+ * Flags for sigprocmask:
+ */
+#define SIG_BLOCK       1       /* block specified signal set */
+#define SIG_UNBLOCK     2       /* unblock specified signal set */
+#define SIG_SETMASK     3       /* set specified signal set */
+
 signalhandler_t signal(int sugnum, signalhandler_t handler);
+int kill(pid_t pid, int sig);
+int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
+
+int sigaddset(sigset_t *set, int signo);
+int sigdelset(sigset_t *set, int signo);
+int sigemptyset(sigset_t *set);
+int sigfillset(sigset_t *set);
+int sigismember(const sigset_t *set, int signo);
 
 #endif // BARRELFISH_SIGNAL_H_
index 0488088..6d4c7e1 100644 (file)
@@ -23,6 +23,7 @@ struct spawninfo {
     struct cnoderef rootcn, taskcn, segcn, pagecn;
     struct capref   rootcn_cap, taskcn_cap, pagecn_cap;
     struct capref   dispframe, dcb, argspg, vtree;
+    struct capref   fdcap;
 
     // Slot (in segcn) from where elfload_allocate should allocate frames from
     cslot_t elfload_slot;
@@ -54,7 +55,8 @@ errval_t spawn_load_with_args(struct spawninfo *si, struct mem_region *module,
 errval_t spawn_load_image(struct spawninfo *si, lvaddr_t binary,
                           size_t binary_size, enum cpu_type type,
                           const char *name, coreid_t coreid,
-                          char *const argv[], char *const envp[]);
+                          char *const argv[], char *const envp[],
+                          struct capref fdcap);
 errval_t spawn_run(struct spawninfo *si);
 errval_t spawn_free(struct spawninfo *si);
 
index f4e86c5..a73132d 100644 (file)
@@ -89,7 +89,7 @@
 typedef __builtin_va_list va_list;
 
 #define va_arg(ap, type) __builtin_va_arg((ap), type)
-#define va_copy(dest, src) __builtin_va_copy((ap), type)
+#define va_copy(dest, src) __builtin_va_copy((dest), (src))
 #define va_end(ap) __builtin_va_end((ap))
 #define va_start(ap, parmN) __builtin_va_start((ap), (parmN))
 
index 0e1e97f..73ff743 100644 (file)
 #endif
 #endif
 
-typedef __PTRDIFF_TYPE__ ptrdiff_t ;
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+
+#ifndef _SIZE_T_DECLARED
 typedef __SIZE_TYPE__ size_t;
+#define _SIZE_T_DECLARED
+#endif
+
+typedef long int ssize_t;
 #ifndef __cplusplus /* FIXME: This is the one concession to C++ programmers that I make.
                       Allowing them to compile and use the standard C library. This is
                       more because C++ people shouldn't be restricted from using wonderful
index cc8370a..534ce4b 100644 (file)
@@ -129,6 +129,8 @@ int setvbuf(FILE *, char *, int, size_t);
 
 /* XXX: POSIX */
 FILE *fdopen(int fd, const char *mode);
+FILE *popen(const char *command, const char *type);
+int pclose(FILE *stream);
 
 /* 7.19.6 Format i/o functions */
 int fprintf(FILE *, const char *, ...) __attribute__ ((format(printf, 2, 3)));
index b349016..5101fd8 100644 (file)
@@ -91,29 +91,35 @@ Author: Ben Leslie
 #define unlock_stream(s) thread_mutex_unlock(&(s)->mutex)
 
 struct __file {
-        void *handle;
+    void *handle;       // Handle to pass to file handling functions
 
-        size_t (*read_fn)(void *, long int, size_t, void *);
-        size_t (*write_fn)(void *, long int, size_t, void *);
-        int (*close_fn)(void *);
-        long int (*eof_fn)(void *);
+    size_t (*read_fn)(void *, long int, size_t, void *);
+    size_t (*write_fn)(void *, long int, size_t, void *);
+    int (*close_fn)(void *);
+    long int (*eof_fn)(void *);
 
-        unsigned char buffering_mode;
-        char *buffer;
-        int buf_pos;
-        int buf_size;
-        int buf_allocated;
+    // Output buffering
+    unsigned char buffering_mode;       // Buffer mode. Can be _IONBF, _IOLBF, _IOFBF
+    char *buffer;   // The output buffer
+    int buf_pos;    // Current position in output buffer
+    int buf_size;   // Allocated size of the buffer
+    int buf_allocated;      // Was the buffer malloc'd (=1) or is it static (=0)?
 
-        unsigned char unget_pos;
-        long int current_pos;
+    // Input buffering
+    char *rbuffer;              // The input buffer
+    char *rbuf_pos;             // Current position in buffer
+    int rbuf_size;              // Allocated size of the buffer
+    int rbuf_valid;             // Remaining valid characters in buffer
 
-        struct thread_mutex mutex;
+    unsigned char unget_pos;    // Position in unget stack
+    size_t current_pos;         // Current position in file
 
-        int eof;
-        int error;
+    struct thread_mutex mutex;  // Mutex to protect file access
 
-        char unget_stack[__UNGET_SIZE];
+    int eof;
+    int error;
+
+    char unget_stack[__UNGET_SIZE];     // The unget stack
 };
 
 #endif // _STDIO_FILE_H_
-
index eeff7d0..d70f699 100644 (file)
@@ -158,6 +158,12 @@ int rand(void);
 void srand(unsigned int seed);
 int rand_r(unsigned int *ctx);
 
+/* from POSIX */
+void srandom(unsigned long x);
+char *initstate(unsigned long seed, char *arg_state, long n);
+char *setstate(char *arg_state);
+long random(void);
+
 /* 7.20.3 Memory management functions */
 
 void *malloc(size_t);
@@ -174,8 +180,9 @@ void _Exit(int status);
 char *getenv(const char *name);
 int system(const char *string);
 
-/* XXX: from POSIX -AB */
+/* from POSIX */
 int setenv(const char *name, const char *value, int overwrite);
+int unsetenv(const char *name);
 
 /* 7.20.5 Searching and sortin utilities */
 void *bsearch(const void *key, const void *base, size_t nmemb, size_t, int (*compar)(const void *, const void*));
@@ -217,4 +224,8 @@ int wctomb(char *s, wchar_t wc);
 size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n);
 size_t wcstombs(char *s, const wchar_t *pwcs, size_t n);
 
+#ifdef _USE_XOPEN
+int putenv(char *string);
+#endif
+
 #endif                          /* _STDLIB_H_ */
diff --git a/include/sys/_sigset.h b/include/sys/_sigset.h
new file mode 100644 (file)
index 0000000..0804a58
--- /dev/null
@@ -0,0 +1,55 @@
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)signal.h    8.4 (Berkeley) 5/4/95
+ * $FreeBSD$
+ */
+
+#ifndef _SYS__SIGSET_H_
+#define        _SYS__SIGSET_H_
+
+/*
+ * sigset_t macros.
+ */
+#define        _SIG_WORDS      4
+#define        _SIG_MAXSIG     128
+#define        _SIG_IDX(sig)   ((sig) - 1)
+#define        _SIG_WORD(sig)  (_SIG_IDX(sig) >> 5)
+#define        _SIG_BIT(sig)   (1 << (_SIG_IDX(sig) & 31))
+#define        _SIG_VALID(sig) ((sig) <= _SIG_MAXSIG && (sig) > 0)
+
+typedef struct __sigset {
+       __uint32_t __bits[_SIG_WORDS];
+} __sigset_t;
+
+#endif /* !_SYS__SIGSET_H_ */
index bf6b4ff..21a106c 100644 (file)
@@ -47,22 +47,37 @@ typedef __uint16_t      u_int16_t;
 typedef __uint32_t      u_int32_t;
 typedef __uint64_t      u_int64_t;
 
-typedef unsigned char   u_char;
+typedef __uint8_t       __sa_family_t;
 
 typedef va_list         __va_list;
 typedef size_t          __size_t;
 
+typedef __uint32_t     __gid_t;
+typedef __uint32_t     __uid_t;
+typedef __int32_t      __clock_t;
+
 typedef int             __ct_rune_t;    /* arg type for ctype funcs */
 typedef __ct_rune_t     __rune_t;       /* rune_t (see above) */
 typedef __ct_rune_t     __wchar_t;      /* wchar_t (see above) */
 typedef __ct_rune_t     __wint_t;       /* wint_t (see above) */
 
+typedef __uint16_t      __mode_t;       /* permissions */
+typedef __int64_t       __off_t;        /* file offset */
+typedef __int32_t       __pid_t;        /* process [group] */
+typedef long            __key_t;        /* IPC key (for Sys V IPC) */
+
 typedef __uint32_t      __dev_t;        /* device number */
 
 typedef __uint32_t      __fixpt_t;      /* fixed point number */
 
 typedef int             __nl_item;
 
+#ifdef __x86_64__
+typedef __int64_t      __time_t;
+#else // XXX: All other archs get 32-bit __time_t
+typedef __int32_t      __time_t;
+#endif
+
 typedef union {
     char            __mbstate8[128];
     __int64_t       _mbstateL;      /* for alignment */
diff --git a/include/sys/file.h b/include/sys/file.h
new file mode 100644 (file)
index 0000000..93f1be4
--- /dev/null
@@ -0,0 +1,289 @@
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)file.h      8.3 (Berkeley) 1/9/95
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_FILE_H_
+#define        _SYS_FILE_H_
+
+#ifndef _KERNEL
+#include <sys/types.h> /* XXX */
+#include <fcntl.h>
+#include <unistd.h>
+#else
+#include <sys/queue.h>
+#include <sys/refcount.h>
+#include <sys/_lock.h>
+#include <sys/_mutex.h>
+
+struct stat;
+struct thread;
+struct uio;
+struct knote;
+struct vnode;
+struct socket;
+
+
+#endif /* _KERNEL */
+
+#define        DTYPE_VNODE     1       /* file */
+#define        DTYPE_SOCKET    2       /* communications endpoint */
+#define        DTYPE_PIPE      3       /* pipe */
+#define        DTYPE_FIFO      4       /* fifo (named pipe) */
+#define        DTYPE_KQUEUE    5       /* event queue */
+#define        DTYPE_CRYPTO    6       /* crypto */
+#define        DTYPE_MQUEUE    7       /* posix message queue */
+#define        DTYPE_SHM       8       /* swap-backed shared memory */
+#define        DTYPE_SEM       9       /* posix semaphore */
+#define        DTYPE_PTS       10      /* pseudo teletype master device */
+
+#ifdef _KERNEL
+
+struct file;
+struct ucred;
+
+typedef int fo_rdwr_t(struct file *fp, struct uio *uio,
+                   struct ucred *active_cred, int flags,
+                   struct thread *td);
+#define        FOF_OFFSET      1       /* Use the offset in uio argument */
+typedef        int fo_truncate_t(struct file *fp, off_t length,
+                   struct ucred *active_cred, struct thread *td);
+typedef        int fo_ioctl_t(struct file *fp, u_long com, void *data,
+                   struct ucred *active_cred, struct thread *td);
+typedef        int fo_poll_t(struct file *fp, int events,
+                   struct ucred *active_cred, struct thread *td);
+typedef        int fo_kqfilter_t(struct file *fp, struct knote *kn);
+typedef        int fo_stat_t(struct file *fp, struct stat *sb,
+                   struct ucred *active_cred, struct thread *td);
+typedef        int fo_close_t(struct file *fp, struct thread *td);
+typedef        int fo_flags_t;
+
+struct fileops {
+       fo_rdwr_t       *fo_read;
+       fo_rdwr_t       *fo_write;
+       fo_truncate_t   *fo_truncate;
+       fo_ioctl_t      *fo_ioctl;
+       fo_poll_t       *fo_poll;
+       fo_kqfilter_t   *fo_kqfilter;
+       fo_stat_t       *fo_stat;
+       fo_close_t      *fo_close;
+       fo_flags_t      fo_flags;       /* DFLAG_* below */
+};
+
+#define DFLAG_PASSABLE 0x01    /* may be passed via unix sockets. */
+#define DFLAG_SEEKABLE 0x02    /* seekable / nonsequential */
+#endif /* _KERNEL */
+
+#if defined(_KERNEL) || defined(_WANT_FILE)
+/*
+ * Kernel descriptor table.
+ * One entry for each open kernel vnode and socket.
+ *
+ * Below is the list of locks that protects members in struct file.
+ *
+ * (f) protected with mtx_lock(mtx_pool_find(fp))
+ * (d) cdevpriv_mtx
+ * none        not locked
+ */
+
+struct file {
+       void            *f_data;        /* file descriptor specific data */
+       struct fileops  *f_ops;         /* File operations */
+       struct ucred    *f_cred;        /* associated credentials. */
+       struct vnode    *f_vnode;       /* NULL or applicable vnode */
+       short           f_type;         /* descriptor type */
+       short           f_vnread_flags; /* (f) Sleep lock for f_offset */
+       volatile u_int  f_flag;         /* see fcntl.h */
+       volatile u_int  f_count;        /* reference count */
+       /*
+        *  DTYPE_VNODE specific fields.
+        */
+       int             f_seqcount;     /* Count of sequential accesses. */
+       off_t           f_nextoff;      /* next expected read/write offset. */
+       struct cdev_privdata *f_cdevpriv; /* (d) Private data for the cdev. */
+       /*
+        *  DFLAG_SEEKABLE specific fields
+        */
+       off_t           f_offset;
+       /*
+        * Mandatory Access control information.
+        */
+       void            *f_label;       /* Place-holder for MAC label. */
+};
+
+#define        FOFFSET_LOCKED       0x1
+#define        FOFFSET_LOCK_WAITING 0x2                 
+
+#endif /* _KERNEL || _WANT_FILE */
+
+/*
+ * Userland version of struct file, for sysctl
+ */
+struct xfile {
+       size_t  xf_size;        /* size of struct xfile */
+       pid_t   xf_pid;         /* owning process */
+       uid_t   xf_uid;         /* effective uid of owning process */
+       int     xf_fd;          /* descriptor number */
+       void    *xf_file;       /* address of struct file */
+       short   xf_type;        /* descriptor type */
+       int     xf_count;       /* reference count */
+       int     xf_msgcount;    /* references from message queue */
+       off_t   xf_offset;      /* file offset */
+       void    *xf_data;       /* file descriptor specific data */
+       void    *xf_vnode;      /* vnode pointer */
+       u_int   xf_flag;        /* flags (see fcntl.h) */
+};
+
+#ifdef _KERNEL
+
+#ifdef MALLOC_DECLARE
+MALLOC_DECLARE(M_FILE);
+#endif
+
+extern struct fileops vnops;
+extern struct fileops badfileops;
+extern struct fileops socketops;
+extern int maxfiles;           /* kernel limit on number of open files */
+extern int maxfilesperproc;    /* per process limit on number of open files */
+extern volatile int openfiles; /* actual number of open files */
+
+int fget(struct thread *td, int fd, struct file **fpp);
+int fget_read(struct thread *td, int fd, struct file **fpp);
+int fget_write(struct thread *td, int fd, struct file **fpp);
+int _fdrop(struct file *fp, struct thread *td);
+
+/*
+ * The socket operations are used a couple of places.
+ * XXX: This is wrong, they should go through the operations vector for
+ * XXX: sockets instead of going directly for the individual functions. /phk
+ */
+fo_rdwr_t      soo_read;
+fo_rdwr_t      soo_write;
+fo_truncate_t  soo_truncate;
+fo_ioctl_t     soo_ioctl;
+fo_poll_t      soo_poll;
+fo_kqfilter_t  soo_kqfilter;
+fo_stat_t      soo_stat;
+fo_close_t     soo_close;
+
+void finit(struct file *, u_int, short, void *, struct fileops *);
+int fgetvp(struct thread *td, int fd, struct vnode **vpp);
+int fgetvp_read(struct thread *td, int fd, struct vnode **vpp);
+int fgetvp_write(struct thread *td, int fd, struct vnode **vpp);
+
+int fgetsock(struct thread *td, int fd, struct socket **spp, u_int *fflagp);
+void fputsock(struct socket *sp);
+
+static __inline int
+_fnoop(void)
+{
+
+       return (0);
+}
+
+#define        fhold(fp)                                                       \
+       (refcount_acquire(&(fp)->f_count))
+#define        fdrop(fp, td)                                                   \
+       (refcount_release(&(fp)->f_count) ? _fdrop((fp), (td)) : _fnoop())
+
+static __inline fo_rdwr_t      fo_read;
+static __inline fo_rdwr_t      fo_write;
+static __inline fo_truncate_t  fo_truncate;
+static __inline fo_ioctl_t     fo_ioctl;
+static __inline fo_poll_t      fo_poll;
+static __inline fo_kqfilter_t  fo_kqfilter;
+static __inline fo_stat_t      fo_stat;
+static __inline fo_close_t     fo_close;
+
+static __inline int
+fo_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
+    int flags, struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_read)(fp, uio, active_cred, flags, td));
+}
+
+static __inline int
+fo_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
+    int flags, struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_write)(fp, uio, active_cred, flags, td));
+}
+
+static __inline int
+fo_truncate(struct file *fp, off_t length, struct ucred *active_cred,
+    struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_truncate)(fp, length, active_cred, td));
+}
+
+static __inline int
+fo_ioctl(struct file *fp, u_long com, void *data, struct ucred *active_cred,
+    struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_ioctl)(fp, com, data, active_cred, td));
+}
+
+static __inline int
+fo_poll(struct file *fp, int events, struct ucred *active_cred,
+    struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_poll)(fp, events, active_cred, td));
+}
+
+static __inline int
+fo_stat(struct file *fp, struct stat *sb, struct ucred *active_cred,
+    struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_stat)(fp, sb, active_cred, td));
+}
+
+static __inline int
+fo_close(struct file *fp, struct thread *td)
+{
+
+       return ((*fp->f_ops->fo_close)(fp, td));
+}
+
+static __inline int
+fo_kqfilter(struct file *fp, struct knote *kn)
+{
+
+       return ((*fp->f_ops->fo_kqfilter)(fp, kn));
+}
+
+#endif /* _KERNEL */
+
+#endif /* !SYS_FILE_H */
diff --git a/include/sys/ioctl.h b/include/sys/ioctl.h
new file mode 100644 (file)
index 0000000..99f94a0
--- /dev/null
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef IOCTL_H
+#define IOCTL_H
+
+int ioctl(int d, int request,  ...);
+
+#endif
diff --git a/include/sys/ipc.h b/include/sys/ipc.h
new file mode 100644 (file)
index 0000000..c72d913
--- /dev/null
@@ -0,0 +1,147 @@
+/*-
+ * Copyright (c) 1988 University of Utah.
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * the Systems Programming Group of the University of Utah Computer
+ * Science Department.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)ipc.h       8.4 (Berkeley) 2/19/95
+ * $FreeBSD$
+ */
+
+/*
+ * SVID compatible ipc.h file
+ */
+#ifndef _SYS_IPC_H_
+#define _SYS_IPC_H_
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#ifndef _GID_T_DECLARED
+typedef        __gid_t         gid_t;
+#define        _GID_T_DECLARED
+#endif
+
+#ifndef _KEY_T_DECLARED
+typedef        __key_t         key_t;
+#define        _KEY_T_DECLARED
+#endif
+
+#ifndef _MODE_T_DECLARED
+typedef        __mode_t        mode_t;
+#define        _MODE_T_DECLARED
+#endif
+
+#ifndef _UID_T_DECLARED
+typedef        __uid_t         uid_t;
+#define        _UID_T_DECLARED
+#endif
+
+#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
+    defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
+struct ipc_perm_old {
+       unsigned short  cuid;   /* creator user id */
+       unsigned short  cgid;   /* creator group id */
+       unsigned short  uid;    /* user id */
+       unsigned short  gid;    /* group id */
+       unsigned short  mode;   /* r/w permission */
+       unsigned short  seq;    /* sequence # (to generate unique ipcid) */
+       key_t           key;    /* user specified msg/sem/shm key */
+};
+#endif
+
+struct ipc_perm {
+       uid_t           cuid;   /* creator user id */
+       gid_t           cgid;   /* creator group id */
+       uid_t           uid;    /* user id */
+       gid_t           gid;    /* group id */
+       mode_t          mode;   /* r/w permission */
+       unsigned short  seq;    /* sequence # (to generate unique ipcid) */
+       key_t           key;    /* user specified msg/sem/shm key */
+};
+
+#if __BSD_VISIBLE
+/* common mode bits */
+#define        IPC_R           000400  /* read permission */
+#define        IPC_W           000200  /* write/alter permission */
+#define        IPC_M           010000  /* permission to change control info */
+#endif
+
+/* SVID required constants (same values as system 5) */
+#define        IPC_CREAT       001000  /* create entry if key does not exist */
+#define        IPC_EXCL        002000  /* fail if key exists */
+#define        IPC_NOWAIT      004000  /* error if request must wait */
+
+#define        IPC_PRIVATE     (key_t)0 /* private key */
+
+#define        IPC_RMID        0       /* remove identifier */
+#define        IPC_SET         1       /* set options */
+#define        IPC_STAT        2       /* get options */
+#if __BSD_VISIBLE
+/*
+ * For Linux compatability.
+ */
+#define        IPC_INFO        3       /* get info */
+#endif
+
+#ifdef _KERNEL
+/* Macros to convert between ipc ids and array indices or sequence ids */
+#define        IPCID_TO_IX(id)         ((id) & 0xffff)
+#define        IPCID_TO_SEQ(id)        (((id) >> 16) & 0xffff)
+#define        IXSEQ_TO_IPCID(ix,perm) (((perm.seq) << 16) | (ix & 0xffff))
+
+struct thread;
+struct proc;
+struct vmspace;
+
+#if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
+    defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
+void   ipcperm_old2new(struct ipc_perm_old *, struct ipc_perm *);
+void   ipcperm_new2old(struct ipc_perm *, struct ipc_perm_old *);
+#endif
+
+int    ipcperm(struct thread *, struct ipc_perm *, int);
+extern void (*shmfork_hook)(struct proc *, struct proc *);
+extern void (*shmexit_hook)(struct vmspace *);
+
+#else /* ! _KERNEL */
+
+__BEGIN_DECLS
+key_t  ftok(const char *, int);
+__END_DECLS
+
+#endif /* _KERNEL */
+
+#endif /* !_SYS_IPC_H_ */
diff --git a/include/sys/param.h b/include/sys/param.h
new file mode 100644 (file)
index 0000000..318e2a8
--- /dev/null
@@ -0,0 +1,256 @@
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)param.h     8.3 (Berkeley) 4/4/95
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_PARAM_H_
+#define _SYS_PARAM_H_
+
+// Heavily stripped down for Barrelfish
+
+#ifndef LOCORE
+#include <sys/types.h>
+#endif
+
+#define        MAXCOMLEN       19              /* max command name remembered */
+#define        MAXINTERP       32              /* max interpreter file name length */
+#define        MAXLOGNAME      17              /* max login name length (incl. NUL) */
+#define        NOGROUP         65535           /* marker for empty group set member */
+#define MAXHOSTNAMELEN 256             /* max hostname size */
+#define SPECNAMELEN    63              /* max length of devicename */
+
+/* More types and definitions used throughout the kernel. */
+#ifdef _KERNEL
+#include <sys/cdefs.h>
+#include <sys/errno.h>
+#ifndef LOCORE
+#include <sys/time.h>
+#include <sys/priority.h>
+#endif
+
+#ifndef FALSE
+#define        FALSE   0
+#endif
+#ifndef TRUE
+#define        TRUE    1
+#endif
+#endif
+
+/* Machine type dependent parameters. */
+//#include <machine/param.h>
+#ifndef _KERNEL
+#include <sys/limits.h>
+#endif
+
+#ifndef DEV_BSHIFT
+#define        DEV_BSHIFT      9               /* log2(DEV_BSIZE) */
+#endif
+#define        DEV_BSIZE       (1<<DEV_BSHIFT)
+
+#ifndef DFLTPHYS
+#define DFLTPHYS       (64 * 1024)     /* default max raw I/O transfer size */
+#endif
+#ifndef MAXPHYS
+#define MAXPHYS                (128 * 1024)    /* max raw I/O transfer size */
+#endif
+
+/*
+ * Constants related to network buffer management.
+ * MCLBYTES must be no larger than PAGE_SIZE.
+ */
+#ifndef        MSIZE
+#define MSIZE          256             /* size of an mbuf */
+#endif /* MSIZE */
+
+#ifndef        MCLSHIFT
+#define MCLSHIFT       11              /* convert bytes to mbuf clusters */
+#endif /* MCLSHIFT */
+
+#define MCLBYTES       (1 << MCLSHIFT) /* size of an mbuf cluster */
+
+#define        MJUM9BYTES      (9 * 1024)      /* jumbo cluster 9k */
+#define        MJUM16BYTES     (16 * 1024)     /* jumbo cluster 16k */
+
+/*
+ * Some macros for units conversion
+ */
+
+/*
+ * btodb() is messy and perhaps slow because `bytes' may be an off_t.  We
+ * want to shift an unsigned type to avoid sign extension and we don't
+ * want to widen `bytes' unnecessarily.  Assume that the result fits in
+ * a daddr_t.
+ */
+#ifndef btodb
+#define btodb(bytes)                   /* calculates (bytes / DEV_BSIZE) */ \
+       (sizeof (bytes) > sizeof(long) \
+        ? (daddr_t)((unsigned long long)(bytes) >> DEV_BSHIFT) \
+        : (daddr_t)((unsigned long)(bytes) >> DEV_BSHIFT))
+#endif
+
+#ifndef dbtob
+#define dbtob(db)                      /* calculates (db * DEV_BSIZE) */ \
+       ((off_t)(db) << DEV_BSHIFT)
+#endif
+
+#define        PRIMASK 0x0ff
+#define        PCATCH  0x100           /* OR'd with pri for tsleep to check signals */
+#define        PDROP   0x200   /* OR'd with pri to stop re-entry of interlock mutex */
+#define        PBDRY   0x400   /* for PCATCH stop is done on the user boundary */
+
+#define        NZERO   0               /* default "nice" */
+
+#define        NBBY    8               /* number of bits in a byte */
+#define        NBPW    sizeof(int)     /* number of bytes per word (integer) */
+
+#define        CMASK   022             /* default file mask: S_IWGRP|S_IWOTH */
+
+#define        NODEV   (dev_t)(-1)     /* non-existent device */
+
+/*
+ * File system parameters and macros.
+ *
+ * MAXBSIZE -  Filesystems are made out of blocks of at most MAXBSIZE bytes
+ *             per block.  MAXBSIZE may be made larger without effecting
+ *             any existing filesystems as long as it does not exceed MAXPHYS,
+ *             and may be made smaller at the risk of not being able to use
+ *             filesystems which require a block size exceeding MAXBSIZE.
+ *
+ * BKVASIZE -  Nominal buffer space per buffer, in bytes.  BKVASIZE is the
+ *             minimum KVM memory reservation the kernel is willing to make.
+ *             Filesystems can of course request smaller chunks.  Actual 
+ *             backing memory uses a chunk size of a page (PAGE_SIZE).
+ *
+ *             If you make BKVASIZE too small you risk seriously fragmenting
+ *             the buffer KVM map which may slow things down a bit.  If you
+ *             make it too big the kernel will not be able to optimally use 
+ *             the KVM memory reserved for the buffer cache and will wind 
+ *             up with too-few buffers.
+ *
+ *             The default is 16384, roughly 2x the block size used by a
+ *             normal UFS filesystem.
+ */
+#define MAXBSIZE       65536   /* must be power of 2 */
+#define BKVASIZE       16384   /* must be power of 2 */
+#define BKVAMASK       (BKVASIZE-1)
+
+/*
+ * MAXPATHLEN defines the longest permissible path length after expanding
+ * symbolic links. It is used to allocate a temporary buffer from the buffer
+ * pool in which to do the name expansion, hence should be a power of two,
+ * and must be less than or equal to MAXBSIZE.  MAXSYMLINKS defines the
+ * maximum number of symbolic links that may be expanded in a path name.
+ * It should be set high enough to allow all legitimate uses, but halt
+ * infinite loops reasonably quickly.
+ */
+#define        MAXPATHLEN      PATH_MAX
+#define MAXSYMLINKS    32
+
+/* Bit map related macros. */
+#define        setbit(a,i)     (((unsigned char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
+#define        clrbit(a,i)     (((unsigned char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
+#define        isset(a,i)                                                      \
+       (((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
+#define        isclr(a,i)                                                      \
+       ((((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
+
+/* Macros for counting and rounding. */
+#ifndef howmany
+#define        howmany(x, y)   (((x)+((y)-1))/(y))
+#endif
+#define        rounddown(x, y) (((x)/(y))*(y))
+#define        roundup(x, y)   ((((x)+((y)-1))/(y))*(y))  /* to any y */
+#define        roundup2(x, y)  (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
+#define powerof2(x)    ((((x)-1)&(x))==0)
+
+/* Macros for min/max. */
+#define        MIN(a,b) (((a)<(b))?(a):(b))
+#define        MAX(a,b) (((a)>(b))?(a):(b))
+
+#ifdef _KERNEL
+/*
+ * Basic byte order function prototypes for non-inline functions.
+ */
+#ifndef LOCORE
+#ifndef _BYTEORDER_PROTOTYPED
+#define        _BYTEORDER_PROTOTYPED
+__BEGIN_DECLS
+__uint32_t      htonl(__uint32_t);
+__uint16_t      htons(__uint16_t);
+__uint32_t      ntohl(__uint32_t);
+__uint16_t      ntohs(__uint16_t);
+__END_DECLS
+#endif
+#endif
+
+#ifndef lint
+#ifndef _BYTEORDER_FUNC_DEFINED
+#define        _BYTEORDER_FUNC_DEFINED
+#define        htonl(x)        __htonl(x)
+#define        htons(x)        __htons(x)
+#define        ntohl(x)        __ntohl(x)
+#define        ntohs(x)        __ntohs(x)
+#endif /* !_BYTEORDER_FUNC_DEFINED */
+#endif /* lint */
+#endif /* _KERNEL */
+
+/*
+ * Scale factor for scaled integers used to count %cpu time and load avgs.
+ *
+ * The number of CPU `tick's that map to a unique `%age' can be expressed
+ * by the formula (1 / (2 ^ (FSHIFT - 11))).  The maximum load average that
+ * can be calculated (assuming 32 bits) can be closely approximated using
+ * the formula (2 ^ (2 * (16 - FSHIFT))) for (FSHIFT < 15).
+ *
+ * For the scheduler to maintain a 1:1 mapping of CPU `tick' to `%age',
+ * FSHIFT must be at least 11; this gives us a maximum load avg of ~1024.
+ */
+#define        FSHIFT  11              /* bits to right of fixed binary point */
+#define FSCALE (1<<FSHIFT)
+
+#define dbtoc(db)                      /* calculates devblks to pages */ \
+       ((db + (ctodb(1) - 1)) >> (PAGE_SHIFT - DEV_BSHIFT))
+#define ctodb(db)                      /* calculates pages to devblks */ \
+       ((db) << (PAGE_SHIFT - DEV_BSHIFT))
+
+/*
+ * Given the pointer x to the member m of the struct s, return
+ * a pointer to the containing structure.
+ */
+#define        member2struct(s, m, x)                                          \
+       ((struct s *)(void *)((char *)(x) - offsetof(struct s, m)))
+
+#endif /* _SYS_PARAM_H_ */
diff --git a/include/sys/shm.h b/include/sys/shm.h
new file mode 100644 (file)
index 0000000..b155b6c
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2007, 2008, 2009, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef SYS_SHM_H
+#define SYS_SHM_H
+
+#include <sys/cdefs.h>
+#include <sys/ipc.h>
+#include <sys/_types.h>
+#include <time.h>
+#include <barrelfish_kpi/paging_arch.h>
+
+#define SHM_RDONLY 010000
+#define SHM_RND 020000
+#define SHMLBA BASE_PAGE_SIZE
+
+#define SHM_R (IPC_R)
+#define SHM_W (IPC_W)
+
+#define        SHM_LOCK 11
+#define        SHM_UNLOCK 12
+
+#define        SHM_STAT 13
+#define        SHM_INFO 14
+
+#ifndef _PID_T_DECLARED
+typedef        __pid_t         pid_t;
+#define        _PID_T_DECLARED
+#endif
+
+#ifndef _TIME_T_DECLARED
+typedef        __time_t        time_t;
+#define        _TIME_T_DECLARED
+#endif
+
+#ifndef _SIZE_T_DECLARED
+typedef        __size_t        size_t;
+#define        _SIZE_T_DECLARED
+#endif
+
+struct shmid_ds {
+    struct ipc_perm shm_perm;
+    size_t shm_segsz;
+    pid_t shm_lpid;
+    pid_t shm_cpid;
+    int shm_nattch;
+    time_t shm_atime;
+    time_t shm_dtime;
+    time_t shm_ctime;
+};
+
+#include <sys/cdefs.h>
+
+#ifndef _SIZE_T_DECLARED
+typedef __size_t        size_t;
+#define _SIZE_T_DECLARED
+#endif
+
+void *shmat(int, const void *, int);
+int shmget(key_t, size_t, int);
+int shmctl(int, int, struct shmid_ds *);
+int shmdt(const void *);
+
+#endif
diff --git a/include/sys/socket.h b/include/sys/socket.h
new file mode 100644 (file)
index 0000000..27494ea
--- /dev/null
@@ -0,0 +1,60 @@
+/*-
+ * Copyright (c) 1982, 1985, 1986, 1988, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      @(#)socket.h    8.4 (Berkeley) 2/21/94
+ * $FreeBSD: head/sys/sys/socket.h 215178 2010-11-12 13:02:26Z luigi $
+ */
+
+#ifndef SOCKET_H
+#define SOCKET_H
+
+#include <lwip/sockets.h>
+
+#if __BSD_VISIBLE
+#define AF_LOCAL        AF_UNIX         /* local to host (pipes, portals) */
+#endif
+#define AF_UNIX         1               /* standardized name for AF_LOCAL */
+
+ssize_t recv(int sockfd, void *buf, size_t len, int flags);
+ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
+                 struct sockaddr *src_addr, socklen_t *addrlen);
+ssize_t send(int sockfd, const void *buf, size_t len, int flags);
+ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
+               const struct sockaddr *dest_addr, socklen_t addrlen);
+int socket(int domain, int type, int protocol);
+int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int listen(int sockfd, int backlog);
+int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+int getsockopt(int sockfd, int level, int optname, void *optval,
+               socklen_t *optlen);
+int setsockopt(int sockfd, int level, int optname, const void *optval,
+               socklen_t optlen);
+int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+
+#endif
index 689dd7e..54266e7 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -10,7 +10,7 @@
 #ifndef STAT_BARRELFISH_H_
 #define STAT_BARRELFISH_H_
 
-#include <sys/types.h> // for mode_t
+#include <sys/types.h> // for mode_t and dev_t
 
 struct stat {
     long st_uid;
@@ -63,5 +63,8 @@ struct stat {
 
 mode_t umask(mode_t mask);
 int chmod(const char *path, mode_t mode);
+int stat(const char *pathname, struct stat *buf);
+int fstat(int fd, struct stat*buf);
+int lstat(const char *path, struct stat *buf);
 
 #endif //  STAT_BARRELFISH_H_
diff --git a/include/sys/termios.h b/include/sys/termios.h
new file mode 100644 (file)
index 0000000..e5bacf4
--- /dev/null
@@ -0,0 +1,5 @@
+/* $FreeBSD$ */
+#ifdef __GNUC__
+#warning "this file includes <sys/termios.h> which is deprecated, use <termios.h> instead"
+#endif
+#include <termios.h>
index 782515f..d9b44ee 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010 ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011 ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -7,13 +7,74 @@
  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  */
 
+/*-
+ * Copyright (c) 1982, 1986, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      @(#)time.h      8.5 (Berkeley) 5/4/95
+ * $FreeBSD: head/sys/sys/time.h 213401 2010-10-04 10:48:47Z phk $
+ */
+
 #ifndef SYS_TIME_BARRELFISH_H_
 #define SYS_TIME_BARRELFISH_H_
 
+struct timezone {
+        int     tz_minuteswest; /* minutes west of Greenwich */
+        int     tz_dsttime;     /* type of dst correction */
+};
+#define DST_NONE        0       /* not on dst */
+#define DST_USA         1       /* USA style dst */
+#define DST_AUST        2       /* Australian style dst */
+#define DST_WET         3       /* Western European dst */
+#define DST_MET         4       /* Middle European dst */
+#define DST_EET         5       /* Eastern European dst */
+#define DST_CAN         6       /* Canada */
+
 /* timeval definition */
 struct timeval {
   long    tv_sec;         /* seconds */
   long    tv_usec;        /* and microseconds */
 };
 
+/*
+ * Names of the interval timers, and structure
+ * defining a timer setting.
+ */
+#define ITIMER_REAL     0
+#define ITIMER_VIRTUAL  1
+#define ITIMER_PROF     2
+
+struct itimerval {
+    struct  timeval it_interval;    /* timer interval */
+    struct  timeval it_value;       /* current value */
+};
+
+int gettimeofday(struct timeval *tv, struct timezone *tz);
+int setitimer(int which, const struct itimerval *new_value,
+              struct itimerval *old_value);
+
 #endif
diff --git a/include/sys/times.h b/include/sys/times.h
new file mode 100644 (file)
index 0000000..b6b1e1d
--- /dev/null
@@ -0,0 +1,62 @@
+/*-
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)times.h     8.4 (Berkeley) 1/21/94
+ * $FreeBSD$
+ */
+
+#ifndef        _SYS_TIMES_H_
+#define        _SYS_TIMES_H_
+
+#include <sys/_types.h>
+
+#ifndef _CLOCK_T_DECLARED
+typedef        __clock_t       clock_t;
+#define        _CLOCK_T_DECLARED
+#endif
+
+struct tms {
+       clock_t tms_utime;      /* User CPU time */
+       clock_t tms_stime;      /* System CPU time */
+       clock_t tms_cutime;     /* User CPU time of terminated child procs */
+       clock_t tms_cstime;     /* System CPU time of terminated child procs */
+};
+
+#ifndef _KERNEL
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+clock_t        times(struct tms *);
+__END_DECLS
+#endif
+#endif /* !_SYS_TIMES_H_ */
index cc1233f..886253b 100644 (file)
@@ -1,10 +1,9 @@
 /**
  * \file sys/types.h
- * \brief Include for libmsun, because it searches types.h in sys
  */
 
 /*
- * Copyright (c) 2007, 2008, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  */
 
+/*-
+ * Copyright (c) 1982, 1986, 1991, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      @(#)types.h     8.6 (Berkeley) 2/19/95
+ * $FreeBSD: head/sys/sys/types.h 210365 2010-07-22 05:42:29Z trasz $
+ */
 
 #ifndef _SYS_TYPES_H
 #define _SYS_TYPES_H
 #include <sys/_types.h>
 #include <barrelfish/types.h>
 
-typedef int mode_t;
-typedef int fd_set;
+#if __BSD_VISIBLE
+typedef unsigned char   u_char;
+typedef unsigned short  u_short;
+typedef unsigned int    u_int;
+typedef unsigned long   u_long;
+#ifndef _KERNEL
+typedef unsigned short  ushort;         /* Sys V compatibility */
+typedef unsigned int    uint;           /* Sys V compatibility */
+#endif
+#endif
+
+//typedef int fd_set;
 typedef long ino_t;
 typedef long dev_t;
-typedef domainid_t pid_t;
+
+#ifndef _MODE_T_DECLARED
+typedef        __mode_t        mode_t;
+#define        _MODE_T_DECLARED
+#endif
+
+#ifndef _OFF_T_DECLARED
+typedef        __off_t         off_t;
+#define        _OFF_T_DECLARED
+#endif
+
+#ifndef _PID_T_DECLARED
+typedef        __pid_t         pid_t;
+#define        _PID_T_DECLARED
+#endif
 
 #endif // _SYS_TYPES_H
diff --git a/include/sys/un.h b/include/sys/un.h
new file mode 100644 (file)
index 0000000..1f4731e
--- /dev/null
@@ -0,0 +1,70 @@
+/*-
+ * Copyright (c) 1982, 1986, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)un.h        8.3 (Berkeley) 2/19/95
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_UN_H_
+#define _SYS_UN_H_
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+
+#ifndef _SA_FAMILY_T_DECLARED
+typedef        __sa_family_t   sa_family_t;
+#define        _SA_FAMILY_T_DECLARED
+#endif
+
+/*
+ * Definitions for UNIX IPC domain.
+ */
+struct sockaddr_un {
+       unsigned char   sun_len;        /* sockaddr len including null */
+       sa_family_t     sun_family;     /* AF_UNIX */
+       char    sun_path[104];          /* path name (gag) */
+};
+
+#if __BSD_VISIBLE
+
+/* Socket options. */
+#define        LOCAL_PEERCRED          0x001   /* retrieve peer credentials */
+#define        LOCAL_CREDS             0x002   /* pass credentials to receiver */
+#define        LOCAL_CONNWAIT          0x004   /* connects block until accepted */
+
+#ifndef _KERNEL
+
+/* actual length of an initialized sockaddr_un */
+#define SUN_LEN(su) \
+       (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
+
+#endif /* !_KERNEL */
+
+#endif /* __BSD_VISIBLE */
+
+#endif /* !_SYS_UN_H_ */
diff --git a/include/sys/wait.h b/include/sys/wait.h
new file mode 100644 (file)
index 0000000..0e23c23
--- /dev/null
@@ -0,0 +1,110 @@
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1993, 1994
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)wait.h      8.2 (Berkeley) 7/10/94
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_WAIT_H_
+#define _SYS_WAIT_H_
+
+#include <sys/cdefs.h>
+
+/*
+ * This file holds definitions relevant to the wait4 system call and the
+ * alternate interfaces that use it (wait, wait3, waitpid).
+ */
+
+/*
+ * Macros to test the exit status returned by wait and extract the relevant
+ * values.
+ */
+#if __BSD_VISIBLE
+#define        WCOREFLAG       0200
+#endif
+#define        _W_INT(i)       (i)
+
+#define        _WSTATUS(x)     (_W_INT(x) & 0177)
+#define        _WSTOPPED       0177            /* _WSTATUS if process is stopped */
+#define        WIFSTOPPED(x)   (_WSTATUS(x) == _WSTOPPED)
+#define        WSTOPSIG(x)     (_W_INT(x) >> 8)
+#define        WIFSIGNALED(x)  (_WSTATUS(x) != _WSTOPPED && _WSTATUS(x) != 0)
+#define        WTERMSIG(x)     (_WSTATUS(x))
+#define        WIFEXITED(x)    (_WSTATUS(x) == 0)
+#define        WEXITSTATUS(x)  (_W_INT(x) >> 8)
+#define        WIFCONTINUED(x) (x == 0x13)     /* 0x13 == SIGCONT */
+#if __BSD_VISIBLE
+#define        WCOREDUMP(x)    (_W_INT(x) & WCOREFLAG)
+
+#define        W_EXITCODE(ret, sig)    ((ret) << 8 | (sig))
+#define        W_STOPCODE(sig)         ((sig) << 8 | _WSTOPPED)
+#endif
+
+/*
+ * Option bits for the third argument of wait4.  WNOHANG causes the
+ * wait to not hang if there are no stopped or terminated processes, rather
+ * returning an error indication in this case (pid==0).  WUNTRACED
+ * indicates that the caller should receive status about untraced children
+ * which stop due to signals.  If children are stopped and a wait without
+ * this option is done, it is as though they were still running... nothing
+ * about them is returned. WNOWAIT only request information about zombie,
+ * leaving the proc around, available for later waits.
+ */
+#define        WNOHANG         1       /* Don't hang in wait. */
+#define        WUNTRACED       2       /* Tell about stopped, untraced children. */
+#define        WSTOPPED        WUNTRACED   /* SUS compatibility */
+#define        WCONTINUED      4       /* Report a job control continued process. */
+#define        WNOWAIT         8       /* Poll only. Don't delete the proc entry. */
+
+#if __BSD_VISIBLE
+#define        WLINUXCLONE 0x80000000  /* Wait for kthread spawned from linux_clone. */
+#endif
+
+/*
+ * Tokens for special values of the "pid" parameter to wait4.
+ */
+#if __BSD_VISIBLE
+#define        WAIT_ANY        (-1)    /* any process */
+#define        WAIT_MYPGRP     0       /* any process in my process group */
+#endif /* __BSD_VISIBLE */
+
+#ifndef _KERNEL
+#include <sys/types.h>
+
+__BEGIN_DECLS
+pid_t  wait(int *);
+pid_t  waitpid(pid_t, int *, int);
+#if __BSD_VISIBLE
+struct rusage;
+pid_t  wait3(int *, int, struct rusage *);
+pid_t  wait4(pid_t, int *, int, struct rusage *);
+#endif
+__END_DECLS
+#endif /* !_KERNEL */
+
+#endif /* !_SYS_WAIT_H_ */
index 2856e23..d7f985a 100644 (file)
 #define _TIME_H_
 
 #include <stddef.h> /* For NULL, size_t */
+#include <sys/_types.h>
 
 #define CLOCKS_PER_SEC 1 /* Arbitrary, 1s resolution */
 
-typedef long clock_t;
-typedef long time_t;
+#ifndef _CLOCK_T_DECLARED
+typedef        __clock_t       clock_t;
+#define        _CLOCK_T_DECLARED
+#endif
+
+#ifndef _TIME_T_DECLARED
+typedef        __time_t        time_t;
+#define        _TIME_T_DECLARED
+#endif
 
 struct tm {
        int tm_sec;
@@ -127,4 +135,8 @@ char *ctime(const time_t *timer)
 size_t strftime(char *s, size_t maxsize, const char *format, 
                const struct tm *timeptr);
 
+#ifdef _USE_XOPEN
+void tzset (void);
+#endif
+
 #endif /* _TIME_H_ */
index a4f41df..4b9f7b0 100644 (file)
@@ -51,7 +51,9 @@
 /* Trace only network related events
  * This will reduce the amount of events recorded, and hence allows
  * recording for longer time. */
-//#define TRACE_ONLY_SUB_NET 1
+#if CONFIG_TRACE && NETWORK_STACK_TRACE
+#define TRACE_ONLY_SUB_NET 1
+#endif // CONFIG_TRACE && NETWORK_STACK_TRACE
 
 /**
  * \brief Constants for trace subsystems and events.
 #define TRACE_EVENT_NET_NI_AI               0X0012 /* added, 0 */
 #define TRACE_EVENT_NET_NI_I                0X0010 /* added, 0 */
 #define TRACE_EVENT_NET_NI_A                0X0003 /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_FILTER_FRAG      0X0018 /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_FILTER_EX_1      0X0015 /* added, pkt data location */
 #define TRACE_EVENT_NET_NI_ARP              0X0011 /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_FILTER_EX_2      0X0016 /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_PKT_CPY_1          0X0019 /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_PKT_CPY_2          0X001A /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_PKT_CPY_3          0X001B /* added, pkt data location */
+#define TRACE_EVENT_NET_NI_PKT_CPY_4          0X001C /* added, pkt data location */
+
+#define TRACE_EVENT_NET_NI_PKT_CPY          0X0017 /* added, pkt data location */
 #define TRACE_EVENT_NET_NI_P                0X0004 /* added, pbuf_id */
 #define TRACE_EVENT_NET_NI_S                0X0005 /* added, pbuf_id */
 #define TRACE_EVENT_NET_AI_A                0X0006 /* added, pbuf_id */
 #define TRACE_EVENT_NET_NO_A                0X000B /* added, client_data (pbuf_address in lwip) */
 #define TRACE_EVENT_NET_NO_S                0X000C /* added, e1000n.c client_data (pbuf_address in lwip) */
 
-/* FIXME: Add the timings of when does NIC gets TX_done
- * This might be killing the performance */
-#define TRACE_EVENT_NET_NO_TXD                0X0013 /* yet to add */
+/* FIXME: Add the timings of when does NIC gets TX_done */
+#define TRACE_EVENT_NET_NO_TXD              0X0013 /* yet to add */
+#define TRACE_EVENT_NET_AIR_R               0x000E /* added, pbuf_addr (TX DONE in app) */
 
 /* Response flow */
-#define TRACE_EVENT_NET_AOR_S               0x000D /* added, pbuf_id */
-#define TRACE_EVENT_NET_AIR_R               0x000E /* added, pbuf_addr */
+#define TRACE_EVENT_NET_AOR_S               0x000D /* added, pbuf_id ( register_pbuf from APP)*/
+#define TRACE_EVENT_NET_NIR_REG_PBUF        0x0014 /* commented pbuf_id ( register_pbuf in NIC)*/
+
 
 
 #define TRACE_EVENT(s,e,a) ((uint64_t)(s)<<48|(uint64_t)(e)<<32|(a))
@@ -581,11 +593,12 @@ static inline errval_t trace_write_event(struct trace_event *ev)
 static inline errval_t trace_event_raw(uint64_t raw)
 {
 #ifdef CONFIG_TRACE
-/*
+
 #if TRACE_ONLY_SUB_NET
+       /* we do not want the stats about actual messages sent */
        return SYS_ERR_OK;
 #endif // TRACE_ONLY_SUB_NET
-*/
+
     struct trace_event ev;
     ev.timestamp = TRACE_TIMESTAMP();
     ev.u.raw = raw;
index bae6d75..eecccf0 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2008, 2009, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
 #define __BF_UNISTD_H
 
 #include <stddef.h>
-#include <sys/types.h> // for pid_t
+#include <sys/types.h>
+#include <pwd.h>
+#include <fcntl.h> // for pid_t
+#include <sys/socket.h>
 
 #define        R_OK 4
 #define        W_OK 2
 #define        STDOUT_FILENO 1
 #define        STDERR_FILENO 2
 
-#define O_RDONLY   00000
-#define O_WRONLY   00001
-#define O_RDWR     00002
-#define O_CREAT    00100
-#define O_EXCL     00200
-#define O_NOCTTY   00400
-#define O_TRUNC    01000       
-#define O_APPEND   02000
-#define O_NONBLOCK 04000
-#define O_SYNC    010000
-#define O_FSYNC          O_SYNC
-#define O_ASYNC          020000
-
 struct stat;
 extern char **environ;
 
 void _exit(int status);
-int open(const char*pathname, int flags, ...);
-int creat (char * file, int mode);
 int read(int fd, void *buf, int len);
 int write(int fd, const void *buf, int len);
 int close(int fd);
-int lseek(int fd, int offset, int whence);
-int stat(const char *pathname, struct stat *buf);
-int fstat(int fd, struct stat*buf);
+off_t lseek(int fd, off_t offset, int whence);
 int ftruncate(int fd, int length);
 int access(const char*pathname,int mode);
 int chdir(const char*pathname);
 int mkdir(const char*pathname,int mode);
 int rmdir(const char*pathname);
+int link(const char *oldpath, const char *newpath);
+int symlink(const char *oldpath, const char *newpath);
 int unlink(const char*pathname);
 int dup(int oldfd);
 int isatty(int fd);
@@ -59,7 +47,16 @@ int dup2(int oldfd, int newfd);
 int pipe(int pipefd[2]);
 char *getcwd(char *buf, size_t size);
 pid_t getpid(void);
+pid_t getppid(void);
 void *sbrk(intptr_t increment);
 long gethostid(void);
+uid_t geteuid(void);
+uid_t getuid(void);
+int fsync(int fd);
+pid_t fork(void);
+int execv(const char *path, char *const argv[]);
+int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
+           struct timeval *timeout);
+int chown(const char *path, uid_t owner, gid_t group);
 
 #endif // __BF_UNISTD_H
index 595d118..03d20f8 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, ETH Zurich.
+ * Copyright (c) 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
 #define VFS_H
 
 #include <stddef.h>
+#include <sys/types.h>
 
 typedef void *vfs_handle_t;
 #define NULL_VFS_HANDLE NULL
 
+//#define WITH_BUFFER_CACHE
+//#define WITH_WRITE_BACK_CACHE
+//#define WITH_META_DATA_CACHE
+
+#ifdef WITH_BUFFER_CACHE
+#define BUFFER_CACHE_BLOCK_SIZE      (1U << 12)      // 4KB
+#endif
+
 /// Enum defining interpretation of offset argument to #vfs_seek
 enum vfs_seekpos {
     VFS_SEEK_SET,   ///< Offset relative to start of file
@@ -59,6 +68,4 @@ errval_t vfs_closedir(vfs_handle_t dhandle);
 errval_t vfs_mount(const char *mountpoint, const char *uri);
 errval_t vfs_unmount(const char *mountpoint);
 
-void vfs_init(void);
-
 #endif
index 6796a67..9ab46f4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, ETH Zurich.
+ * Copyright (c) 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -17,5 +17,6 @@
 
 void vfs_path_normalise(char *path);
 char *vfs_path_mkabsolute(const char *cwd, const char *path);
+char *vfs_path_mkabs(const char *path);
 
 #endif
index 5fbe24f..d27b74c 100644 (file)
@@ -53,7 +53,7 @@ in [
         in_x86_dir f = ("arch/x86") ./. f
         x86_cFiles = [ "apic.c", "pic.c", "start_aps.c", "cmos.c", "misc.c",
                        "serial.c", "multiboot.c", "conio.c", "syscall.c", "debugregs.c",
-                       "perfmon_intel.c", "perfmon_amd.c", "rtc.c", "timing.c",
+                       "perfmon.c", "perfmon_intel.c", "perfmon_amd.c", "rtc.c", "timing.c",
                        "startup_x86.c", "mcheck.c", "ipi_notify.c" ]
         x86_sFiles = [ "init_ap_x86_64.S", "init_ap_x86_32.S" ]
         absolute_cFiles = (map in_x86_dir x86_cFiles)
@@ -70,7 +70,7 @@ in [
         in_x86_dir f = ("arch/x86") ./. f
         x86_cFiles = [ "apic.c", "pic.c", "start_aps.c", "cmos.c", "misc.c",
                        "serial.c", "multiboot.c", "conio.c", "syscall.c", "debugregs.c",
-                       "perfmon_intel.c", "perfmon_amd.c", "rtc.c", "timing.c",
+                       "perfmon.c", "perfmon_intel.c", "perfmon_amd.c", "rtc.c", "timing.c",
                        "startup_x86.c", "ipi_notify.c" ]
         x86_sFiles = [ "init_ap_x86_64.S", "init_ap_x86_32.S" ]
         absolute_cFiles = (map in_x86_dir x86_cFiles)
@@ -108,9 +108,9 @@ in [
         indep_sFiles = (map in_x86_dir x86_sFiles)
         mackerelFiles =
             if Config.rck_emu then
-                [ "pc16550d_uart", "ia32", "xapic", "rck", "lpc_pic", "cmos", "cpuid" ]
+                [ "pc16550d_uart", "ia32", "xapic", "rck", "eMAC", "lpc_pic", "cmos", "cpuid" ]
             else
-                [ "pc16550d_uart", "ia32", "xapic", "rck", "cpuid" ]
+                [ "pc16550d_uart", "ia32", "xapic", "rck", "eMAC", "cpuid" ]
         libs = [ "elf_kernel" ]
     in mkrules "scc" cfiles sfiles mackerelFiles libs indep_cFiles indep_sFiles arch_cfiles arch_sfiles),
 
index 5944eda..efd4f58 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, ETH Zurich.
+ * Copyright (c) 2009, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -243,6 +243,40 @@ monitor_handle_register(
     return sys_monitor_register(ep_caddr);
 }
 
+static struct sysret
+monitor_create_cap(
+    struct capability *kernel_cap,
+    arch_registers_state_t* context,
+    int argc
+    )
+{
+    assert(6 == argc);
+
+    struct registers_arm_syscall_args* sa = &context->syscall_args;
+
+    printf("%d: %d, %d, %d, %d, %d, %d\n", argc, sa->arg0, sa->arg1, sa->arg2, sa->arg3, sa->arg4, sa->arg5);
+
+    /* Create the cap in the destination */
+    caddr_t cnode_cptr = sa->arg2;
+    int cnode_vbits    = sa->arg3;
+    size_t slot        = sa->arg4;
+    struct capability *src =
+        (struct capability*)sa->arg5;
+
+    printf("type = %d\n", src->type);
+
+    /* Certain types cannot be created here */
+    if ((src->type == ObjType_Null) || (src->type == ObjType_EndPoint)
+        || (src->type == ObjType_Dispatcher) || (src->type == ObjType_Kernel)
+        || (src->type == ObjType_IRQTable)) {
+        return SYSRET(SYS_ERR_ILLEGAL_DEST_TYPE);
+    }
+
+    return SYSRET(caps_create_from_existing(&dcb_current->cspace.cap,
+                                            cnode_cptr, cnode_vbits,
+                                            slot, src));
+}
+
 typedef struct sysret (*invocation_t)(struct capability*, arch_registers_state_t*, int);
 
 static invocation_t invocations[ObjType_Num][CAP_MAX_CMD] = {
@@ -267,6 +301,7 @@ static invocation_t invocations[ObjType_Num][CAP_MAX_CMD] = {
     [ObjType_Kernel] = {
         [KernelCmd_Get_core_id] = monitor_get_core_id,
         [KernelCmd_Register]    = monitor_handle_register,
+        [KernelCmd_Create_cap]  = monitor_create_cap,
     }
 };
 
index 320af5f..e36b9b0 100644 (file)
@@ -206,6 +206,50 @@ void rck_init(void)
             memset((void *)mpb[i], 0, 4 * BASE_PAGE_SIZE);
         }
     }
+
+    // Map more shared RAM (960MB more)
+    static int addr[19] = {0x28, 0x51, 0x7a, 0xa3, 0xcc, 0xf5, 0x11e, 0x147, 0x170, 0x199, 0x1c2, 0x1eb, 0x1ed, 0x1ee, 0x1ef, 0x1f0, 0x1f1, 0x1f2, 0x1f3};
+    for(int i = 0; i < 76; i++) {
+        int current_lut;
+        if(i < 60) {
+            current_lut = 132 + i;
+        } else {
+            current_lut = 127 - (i - 60);
+        }
+        rck_lute_t lut = {
+            .bypass = 0
+        };
+
+        switch(i / 19) {
+        case 0:
+            lut.route = 0;
+            lut.subdest = rck_mc1_sd;
+            break;
+
+        case 1:
+            lut.route = 5;
+            lut.subdest = rck_mc2_sd;
+            break;
+
+        case 2:
+            lut.route = 0x20;
+            lut.subdest = rck_mc1_sd;
+            break;
+
+        case 3:
+            lut.route = 0x25;
+            lut.subdest = rck_mc2_sd;
+            break;
+
+        default:
+            assert(!"shouldn't happen");
+        };
+
+        lut.addrbits = addr[i % 19];
+
+        rck_lut0_wr(&rck_own, current_lut, lut);
+        rck_lut1_wr(&rck_own, current_lut, lut);
+    }
 }
 
 #define NUM_ROWS 4
@@ -251,7 +295,7 @@ static void handle_channel(uintptr_t chanid)
         printk(LOG_WARN, "unhandled RCK channel %d\n", chanid);
         return;
     } else {
-        /* printf("handle_channel(%d)\n", chanid); */
+      /* printf("%d: handle_channel(%d)\n", my_core_id, chanid); */
     }
     assert(ep->type == ObjType_EndPoint);
 
@@ -302,7 +346,7 @@ void rck_send_notification(uint8_t dest, uintptr_t chanid)
     cl[6] = 0;
     cl[7] = 0;
 
-    /* printf("rck_send_notification(%u (%d, %d), %u), 0x%x\n", dest, tile, core, chanid, vaddr); */
+    /* printf("%d: rck_send_notification(%u (%d, %d), %u)\n", my_core_id, dest, tile, core, chanid); */
 
     assert(reader_pos != (writer_pos + 1) % RING_SIZE);
 
@@ -402,6 +446,57 @@ void rck_handle_notification(void)
     release_lock(myself);
 }
 
+void rck_reset_lint1(void)
+{
+    uint8_t myself = rck_get_coreid();
+    int tile = myself / 2, core = myself % 2;
+    uint32_t glcfg = rck_glcfg_rd_raw(&rck[tile], core);
+    glcfg &= ~1;
+    rck_glcfg_wr_raw(&rck[tile], core, glcfg);
+}
+
+errval_t rck_get_route(genpaddr_t base, size_t size, uint8_t *route,
+                       uint8_t *subdest, uint16_t *addrbits)
+{
+    uint8_t myself = rck_get_coreid();
+    int tile = myself / 2, core = myself % 2;
+    uint32_t lute;
+    genpaddr_t index = base >> 24;
+    assert(index < 256);
+    bool first = true;
+    assert(index + (size / LUT_SIZE) < 256);
+
+    // This is probably overkill. A device is probably only able to
+    // route to exactly one LUT mapping, and not multiple consecutive
+    // ones.
+    printf("#### base %"PRIxGENPADDR", %zu\n", base, size);
+    for(genpaddr_t i = 0; i <= size / LUT_SIZE; i++) {
+        if(core == 0) {
+            lute = rck_lut0_rd_raw(&rck[tile], index + i);
+        } else {
+            lute = rck_lut1_rd_raw(&rck[tile], index + i);
+        }
+
+        uint8_t myroute = (lute >> 13) & 0xff;
+        uint8_t mysubdest = (lute >> 10) & 0b111;
+        uint16_t myaddrbits = lute & 0x3ff;
+        printf("#### myroute = %x, %x %x\n", myroute, mysubdest, myaddrbits);
+        if(!first) {
+            if(myroute != *route || mysubdest != *subdest
+               || myaddrbits != *addrbits + i) {
+                return SYS_ERR_CROSS_MC;
+            }
+        } else {
+            *route = myroute;
+            *subdest = mysubdest;
+            *addrbits = myaddrbits;
+            first = false;
+        }
+    }
+
+    return SYS_ERR_OK;
+}
+
 errval_t rck_register_notification(caddr_t ep, int chanid)
 {
     struct cte *recv;
@@ -447,9 +542,9 @@ errval_t rck_delete_notification(int chanid)
 }
 
 #define CORES_PER_QUADRANT      12
-#define LUTS_PER_CORE           20
-#define XCORE_LUT_BASE          20
-#define XCORE_PADDR_BASE        0x14000000
+/* #define LUTS_PER_CORE           20 */
+#define XCORE_LUT_BASE          41
+#define XCORE_PADDR_BASE        0x29000000
 
 struct mcdest {
     int route;
@@ -782,9 +877,9 @@ int rck_start_core(uint8_t coreid, genvaddr_t entry, struct x86_core_data *core_
 
     int route = dests[coreid].route;
     rck_mcsubdests_t subdest = dests[coreid].subdest;
-    int addrbits = dests[coreid].addrbits * 0x14;
+    int addrbits = dests[coreid].addrbits * 0x29;
 
-    // Map core's memory at LUT entry 20
+    // Map core's memory at LUT entry 41
     // XXX: Something's utterly wrong here! The register isn't written correctly.
     // route is 11b, even though it should be 0.
 #if 0
@@ -808,7 +903,7 @@ int rck_start_core(uint8_t coreid, genvaddr_t entry, struct x86_core_data *core_
     lvaddr_t mem = paging_map_device(xcore_paddr + 0x100000 - BASE_PAGE_SIZE, BASE_PAGE_SIZE);
     assert(mem != 0);
 
-    /* for(lpaddr_t base = XCORE_PADDR; base < XCORE_PADDR + LUT_SIZE; base += BASE_PAGE_SIZE) { */        
+    /* for(lpaddr_t base = XCORE_PADDR; base < XCORE_PADDR + LUT_SIZE; base += BASE_PAGE_SIZE) { */
     /* } */
 
     // XXX: Copy given core_data to destination
index 54adfdf..fe71b1e 100644 (file)
@@ -4,7 +4,7 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE file.
@@ -50,6 +50,35 @@ void apic_timer_init(bool masked, bool periodic)
         );
 }
 
+/**
+ * \brief Initializes performance counter overflow interrupt
+ *
+ */
+void apic_perfcnt_init(void)
+{
+    // Activate use of APIC performance counter interrupts
+    xapic_lvt_perf_cnt_wr(&apic, (xapic_lvt_mon_t) {
+            .vector = APIC_PERFORMANCE_INTERRUPT_VECTOR,
+                .msgType = 0,
+                .mask = 0
+            }
+        );
+}
+/**
+ * \brief Initializes performance counter overflow interrupt
+ *
+ */
+void apic_perfcnt_stop(void)
+{
+    // Activate use of APIC performance counter interrupts
+    xapic_lvt_perf_cnt_wr(&apic, (xapic_lvt_mon_t) {
+            .vector = APIC_PERFORMANCE_INTERRUPT_VECTOR,
+                .msgType = 0,
+                .mask = 1
+            }
+        );
+}
+
 void apic_timer_set_count(uint32_t count)
 {
     xapic_init_count_wr(&apic, count);
@@ -144,11 +173,6 @@ void apic_init(void)
                 .vector = APIC_THERMAL_INTERRUPT_VECTOR,
                 .mask = xapic_masked } );
 
-    //performance monitoring counters
-    xapic_lvt_perfmon_wr(&apic, (xapic_lvt_mon_t) {
-                .vector = APIC_PERFORMANCE_INTERRUPT_VECTOR,
-                .mask = xapic_masked } );
-
 #if defined(__scc__) && !defined(RCK_EMU)
     //LINT0: inter-core interrupt
     //generate fixed int
@@ -159,13 +183,12 @@ void apic_init(void)
                .mask = xapic_not_masked } );
 
     //LINT1: usually used to generate an NMI
-    //generate NMI
-    //disabled (FIXME?)
+    //generate device interrupt
     xapic_lvt_lint1_wr(&apic, (xapic_lvt_lint_t) {
-                .vector = 0,
-               .dlv_mode = xapic_nmi,
+                .vector = 32,
+               .dlv_mode = xapic_fixed,
                 .trig_mode = xapic_edge,
-                .mask = xapic_masked } );
+                .mask = xapic_not_masked } );
 #else
     //LINT0: external interrupts, delivered by the 8259 PIC
     //generate extInt as if INTR pin were activated
diff --git a/kernel/arch/x86/perfmon.c b/kernel/arch/x86/perfmon.c
new file mode 100644 (file)
index 0000000..3cc5b1b
--- /dev/null
@@ -0,0 +1,139 @@
+/**
+ * \file
+ * \brief AMD performance monitoring infrastructure.
+ */
+
+/*
+ * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#include <kernel.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <capabilities.h>
+#include <arch/x86/perfmon_amd.h>
+#include <arch/x86/perfmon_intel.h>
+#include <arch/x86/perfmon.h>
+#include <arch/x86/apic.h>
+
+static bool perfmon_amd = false;
+static bool perfmon_intel = false;
+/* static bool perfmon_measurement_running = false; */
+/* static bool perfmon_apic_activated = false; */
+static uint64_t perfmon_cntr_init = 0;
+struct capability perfmon_callback_ep;
+
+
+void perfmon_init(void) 
+{
+    // Return if init already done .. 
+    if(perfmon_amd || perfmon_intel) {
+        return;
+    }
+
+    // Try to initialize on intel.
+    if(err_is_fail(perfmon_intel_init())) {
+        // Try amd
+        perfmon_amd_init();
+        // Check amd
+        perfmon_amd = perfmon_amd_supported();
+    } else {
+        perfmon_intel = true;
+    }
+
+    // Debug output
+    if(perfmon_intel) {
+        printf("Activated perfmon for Intel!\n");
+    } else if(perfmon_amd) {
+        printf("Activated perfmon for AMD!\n");
+    } else {
+        printf("Perfmon activation failed. "
+               "Neither Intel nor AMD support detected\n");
+    }
+}
+
+/*
+ * \brief Initialize measuring for performance analysis.
+ *
+ * An overflow will be registered and the counter will set such that this 
+ * overflow occures every ctr counter steps.
+ */
+void perfmon_measure_start(uint8_t event, uint8_t umask, 
+                           uint8_t counter_id, bool kernel, uint64_t ctr)
+{
+    // Activate APIC interrupts for overflow if init successful
+    if(ctr!=0) {
+        if(perfmon_amd || perfmon_intel) {
+            apic_perfcnt_init();
+        }
+    }
+
+    // Activate performance measurement for Intel
+    if(perfmon_amd) {
+        
+        perfmon_amd_measure_write(ctr*-1, 0);
+        perfmon_amd_measure_start(event, umask, kernel, counter_id, ctr!=0);
+        perfmon_cntr_init = ctr;
+    }
+}
+
+/*
+ * Re-Initialize counter after overflow.
+ * This function is called from the interrupt processing.
+ */
+void perfmon_measure_reset(void)
+{
+    if(perfmon_amd) {
+        perfmon_amd_measure_write(perfmon_cntr_init*-1, 0);
+    }
+}
+    
+
+uint64_t perfmon_measure_read(void)
+{
+    if(perfmon_amd) {