linuxstart-20120111.tar.gz

tmp/linuxstart-20120111/0000755000076400001440000000000011703377274014323 5ustar  bellarduserstmp/linuxstart-20120111/linuxstart_head.S0000640000076400001440000000305111703377274017640 0ustar  bellardusers/*
 * JS/Linux Linux starter
 *
 * Copyright (c) 2011 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "linuxstart.h"
        
.globl _start
        
_start:
        movl $stack_end, %esp
        pushl %ecx // cmdline
        pushl %ebx // initrd_size
        pushl %eax // phys_ram_size
        call setup
        addl $12, %esp
/* start linux kernel */
        movl $KERNEL_PARAMS_ADDR, %esi
        ljmp $KERNEL_CS, $KERNEL_LOAD_ADDR

        .org 0x1000
start_start:
        /* stack */
        .org 0x3000
stack_end:
tmp/linuxstart-20120111/linuxstart.h0000640000076400001440000000243611703377274016712 0ustar  bellardusers/*
 * JS/Linux Linux starter
 *
 * Copyright (c) 2011 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#define KERNEL_LOAD_ADDR   0x00100000
#define INITRD_LOAD_ADDR   0x00400000
#define KERNEL_PARAMS_ADDR 0x00090000

#define KERNEL_CS 0x10
#define KERNEL_DS 0x18
tmp/linuxstart-20120111/config_linux-2.6.200000640000076400001440000005001111703377274017446 0ustar  bellardusers#
# Automatically generated make config: don't edit
# Linux kernel version: 2.6.20
# Wed Jan 11 01:11:15 2012
#
CONFIG_X86_32=y
CONFIG_GENERIC_TIME=y
CONFIG_LOCKDEP_SUPPORT=y
CONFIG_STACKTRACE_SUPPORT=y
CONFIG_SEMAPHORE_SLEEPERS=y
CONFIG_X86=y
CONFIG_MMU=y
CONFIG_GENERIC_ISA_DMA=y
CONFIG_GENERIC_IOMAP=y
CONFIG_GENERIC_BUG=y
CONFIG_GENERIC_HWEIGHT=y
CONFIG_ARCH_MAY_HAVE_PC_FDC=y
CONFIG_DMI=y
CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"

#
# Code maturity level options
#
CONFIG_EXPERIMENTAL=y
CONFIG_BROKEN_ON_SMP=y
CONFIG_INIT_ENV_ARG_LIMIT=32

#
# General setup
#
CONFIG_LOCALVERSION=""
CONFIG_LOCALVERSION_AUTO=y
CONFIG_SWAP=y
CONFIG_SYSVIPC=y
# CONFIG_IPC_NS is not set
CONFIG_POSIX_MQUEUE=y
CONFIG_BSD_PROCESS_ACCT=y
# CONFIG_BSD_PROCESS_ACCT_V3 is not set
# CONFIG_TASKSTATS is not set
# CONFIG_UTS_NS is not set
# CONFIG_AUDIT is not set
# CONFIG_IKCONFIG is not set
CONFIG_SYSFS_DEPRECATED=y
# CONFIG_RELAY is not set
CONFIG_INITRAMFS_SOURCE=""
# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
CONFIG_SYSCTL=y
CONFIG_EMBEDDED=y
CONFIG_UID16=y
CONFIG_SYSCTL_SYSCALL=y
CONFIG_KALLSYMS=y
CONFIG_KALLSYMS_EXTRA_PASS=y
CONFIG_HOTPLUG=y
CONFIG_PRINTK=y
CONFIG_BUG=y
CONFIG_ELF_CORE=y
CONFIG_BASE_FULL=y
CONFIG_FUTEX=y
CONFIG_EPOLL=y
CONFIG_SHMEM=y
CONFIG_SLAB=y
CONFIG_VM_EVENT_COUNTERS=y
CONFIG_RT_MUTEXES=y
# CONFIG_TINY_SHMEM is not set
CONFIG_BASE_SMALL=0
# CONFIG_SLOB is not set

#
# Loadable module support
#
# CONFIG_MODULES is not set

#
# Block layer
#
CONFIG_BLOCK=y
CONFIG_LBD=y
# CONFIG_BLK_DEV_IO_TRACE is not set
# CONFIG_LSF is not set

#
# IO Schedulers
#
CONFIG_IOSCHED_NOOP=y
CONFIG_IOSCHED_AS=y
CONFIG_IOSCHED_DEADLINE=y
CONFIG_IOSCHED_CFQ=y
# CONFIG_DEFAULT_AS is not set
# CONFIG_DEFAULT_DEADLINE is not set
CONFIG_DEFAULT_CFQ=y
# CONFIG_DEFAULT_NOOP is not set
CONFIG_DEFAULT_IOSCHED="cfq"

#
# Processor type and features
#
# CONFIG_SMP is not set
CONFIG_X86_PC=y
# CONFIG_X86_ELAN is not set
# CONFIG_X86_VOYAGER is not set
# CONFIG_X86_NUMAQ is not set
# CONFIG_X86_SUMMIT is not set
# CONFIG_X86_BIGSMP is not set
# CONFIG_X86_VISWS is not set
# CONFIG_X86_GENERICARCH is not set
# CONFIG_X86_ES7000 is not set
# CONFIG_PARAVIRT is not set
# CONFIG_M386 is not set
CONFIG_M486=y
# CONFIG_M586 is not set
# CONFIG_M586TSC is not set
# CONFIG_M586MMX is not set
# CONFIG_M686 is not set
# CONFIG_MPENTIUMII is not set
# CONFIG_MPENTIUMIII is not set
# CONFIG_MPENTIUMM is not set
# CONFIG_MCORE2 is not set
# CONFIG_MPENTIUM4 is not set
# CONFIG_MK6 is not set
# CONFIG_MK7 is not set
# CONFIG_MK8 is not set
# CONFIG_MCRUSOE is not set
# CONFIG_MEFFICEON is not set
# CONFIG_MWINCHIPC6 is not set
# CONFIG_MWINCHIP2 is not set
# CONFIG_MWINCHIP3D is not set
# CONFIG_MGEODEGX1 is not set
# CONFIG_MGEODE_LX is not set
# CONFIG_MCYRIXIII is not set
# CONFIG_MVIAC3_2 is not set
CONFIG_X86_GENERIC=y
CONFIG_X86_CMPXCHG=y
CONFIG_X86_XADD=y
CONFIG_X86_L1_CACHE_SHIFT=7
CONFIG_RWSEM_XCHGADD_ALGORITHM=y
# CONFIG_ARCH_HAS_ILOG2_U32 is not set
# CONFIG_ARCH_HAS_ILOG2_U64 is not set
CONFIG_GENERIC_CALIBRATE_DELAY=y
CONFIG_X86_PPRO_FENCE=y
CONFIG_X86_F00F_BUG=y
CONFIG_X86_WP_WORKS_OK=y
CONFIG_X86_INVLPG=y
CONFIG_X86_BSWAP=y
CONFIG_X86_POPAD_OK=y
CONFIG_X86_ALIGNMENT_16=y
CONFIG_X86_INTEL_USERCOPY=y
# CONFIG_HPET_TIMER is not set
CONFIG_PREEMPT_NONE=y
# CONFIG_PREEMPT_VOLUNTARY is not set
# CONFIG_PREEMPT is not set
# CONFIG_X86_UP_APIC is not set
# CONFIG_X86_MCE is not set
CONFIG_VM86=y
# CONFIG_TOSHIBA is not set
# CONFIG_I8K is not set
# CONFIG_X86_REBOOTFIXUPS is not set
# CONFIG_MICROCODE is not set
# CONFIG_X86_MSR is not set
# CONFIG_X86_CPUID is not set

#
# Firmware Drivers
#
# CONFIG_EDD is not set
# CONFIG_DELL_RBU is not set
# CONFIG_DCDBAS is not set
CONFIG_NOHIGHMEM=y
# CONFIG_HIGHMEM4G is not set
# CONFIG_HIGHMEM64G is not set
CONFIG_VMSPLIT_3G=y
# CONFIG_VMSPLIT_3G_OPT is not set
# CONFIG_VMSPLIT_2G is not set
# CONFIG_VMSPLIT_1G is not set
CONFIG_PAGE_OFFSET=0xC0000000
CONFIG_ARCH_FLATMEM_ENABLE=y
CONFIG_ARCH_SPARSEMEM_ENABLE=y
CONFIG_ARCH_SELECT_MEMORY_MODEL=y
CONFIG_ARCH_POPULATES_NODE_MAP=y
CONFIG_SELECT_MEMORY_MODEL=y
CONFIG_FLATMEM_MANUAL=y
# CONFIG_DISCONTIGMEM_MANUAL is not set
# CONFIG_SPARSEMEM_MANUAL is not set
CONFIG_FLATMEM=y
CONFIG_FLAT_NODE_MEM_MAP=y
CONFIG_SPARSEMEM_STATIC=y
CONFIG_SPLIT_PTLOCK_CPUS=4
# CONFIG_RESOURCES_64BIT is not set
CONFIG_MATH_EMULATION=y
# CONFIG_MTRR is not set
# CONFIG_SECCOMP is not set
CONFIG_HZ_100=y
# CONFIG_HZ_250 is not set
# CONFIG_HZ_300 is not set
# CONFIG_HZ_1000 is not set
CONFIG_HZ=100
# CONFIG_KEXEC is not set
CONFIG_PHYSICAL_START=0x100000
# CONFIG_RELOCATABLE is not set
CONFIG_PHYSICAL_ALIGN=0x100000
CONFIG_COMPAT_VDSO=y

#
# Power management options (ACPI, APM)
#
# CONFIG_PM is not set

#
# ACPI (Advanced Configuration and Power Interface) Support
#

#
# CPU Frequency scaling
#
# CONFIG_CPU_FREQ is not set

#
# Bus options (PCI, PCMCIA, EISA, MCA, ISA)
#
# CONFIG_PCI is not set
CONFIG_ISA_DMA_API=y
CONFIG_ISA=y
# CONFIG_EISA is not set
# CONFIG_MCA is not set
# CONFIG_SCx200 is not set

#
# PCCARD (PCMCIA/CardBus) support
#
# CONFIG_PCCARD is not set

#
# PCI Hotplug Support
#

#
# Executable file formats
#
CONFIG_BINFMT_ELF=y
# CONFIG_BINFMT_AOUT is not set
CONFIG_BINFMT_MISC=y

#
# Networking
#
CONFIG_NET=y

#
# Networking options
#
# CONFIG_NETDEBUG is not set
CONFIG_PACKET=y
CONFIG_PACKET_MMAP=y
CONFIG_UNIX=y
CONFIG_XFRM=y
# CONFIG_XFRM_USER is not set
# CONFIG_XFRM_SUB_POLICY is not set
# CONFIG_NET_KEY is not set
CONFIG_INET=y
CONFIG_IP_MULTICAST=y
CONFIG_IP_ADVANCED_ROUTER=y
CONFIG_ASK_IP_FIB_HASH=y
# CONFIG_IP_FIB_TRIE is not set
CONFIG_IP_FIB_HASH=y
CONFIG_IP_MULTIPLE_TABLES=y
CONFIG_IP_ROUTE_MULTIPATH=y
# CONFIG_IP_ROUTE_MULTIPATH_CACHED is not set
CONFIG_IP_ROUTE_VERBOSE=y
# CONFIG_IP_PNP is not set
# CONFIG_NET_IPIP is not set
# CONFIG_NET_IPGRE is not set
CONFIG_IP_MROUTE=y
CONFIG_IP_PIMSM_V1=y
CONFIG_IP_PIMSM_V2=y
# CONFIG_ARPD is not set
CONFIG_SYN_COOKIES=y
# CONFIG_INET_AH is not set
# CONFIG_INET_ESP is not set
# CONFIG_INET_IPCOMP is not set
# CONFIG_INET_XFRM_TUNNEL is not set
# CONFIG_INET_TUNNEL is not set
CONFIG_INET_XFRM_MODE_TRANSPORT=y
CONFIG_INET_XFRM_MODE_TUNNEL=y
CONFIG_INET_XFRM_MODE_BEET=y
CONFIG_INET_DIAG=y
CONFIG_INET_TCP_DIAG=y
# CONFIG_TCP_CONG_ADVANCED is not set
CONFIG_TCP_CONG_CUBIC=y
CONFIG_DEFAULT_TCP_CONG="cubic"
# CONFIG_TCP_MD5SIG is not set

#
# IP: Virtual Server Configuration
#
# CONFIG_IP_VS is not set
# CONFIG_IPV6 is not set
# CONFIG_INET6_XFRM_TUNNEL is not set
# CONFIG_INET6_TUNNEL is not set
# CONFIG_NETWORK_SECMARK is not set
CONFIG_NETFILTER=y
# CONFIG_NETFILTER_DEBUG is not set

#
# Core Netfilter Configuration
#
# CONFIG_NETFILTER_NETLINK is not set
# CONFIG_NF_CONNTRACK_ENABLED is not set
# CONFIG_NETFILTER_XTABLES is not set

#
# IP: Netfilter Configuration
#
# CONFIG_IP_NF_QUEUE is not set

#
# DCCP Configuration (EXPERIMENTAL)
#
# CONFIG_IP_DCCP is not set

#
# SCTP Configuration (EXPERIMENTAL)
#
# CONFIG_IP_SCTP is not set

#
# TIPC Configuration (EXPERIMENTAL)
#
# CONFIG_TIPC is not set
# CONFIG_ATM is not set
# CONFIG_BRIDGE is not set
# CONFIG_VLAN_8021Q is not set
# CONFIG_DECNET is not set
# CONFIG_LLC2 is not set
# CONFIG_IPX is not set
# CONFIG_ATALK is not set
# CONFIG_X25 is not set
# CONFIG_LAPB is not set
# CONFIG_ECONET is not set
# CONFIG_WAN_ROUTER is not set

#
# QoS and/or fair queueing
#
CONFIG_NET_SCHED=y
CONFIG_NET_SCH_FIFO=y
CONFIG_NET_SCH_CLK_JIFFIES=y
# CONFIG_NET_SCH_CLK_GETTIMEOFDAY is not set
# CONFIG_NET_SCH_CLK_CPU is not set

#
# Queueing/Scheduling
#
# CONFIG_NET_SCH_CBQ is not set
# CONFIG_NET_SCH_HTB is not set
# CONFIG_NET_SCH_HFSC is not set
# CONFIG_NET_SCH_PRIO is not set
# CONFIG_NET_SCH_RED is not set
# CONFIG_NET_SCH_SFQ is not set
# CONFIG_NET_SCH_TEQL is not set
# CONFIG_NET_SCH_TBF is not set
# CONFIG_NET_SCH_GRED is not set
# CONFIG_NET_SCH_DSMARK is not set
# CONFIG_NET_SCH_NETEM is not set
# CONFIG_NET_SCH_INGRESS is not set

#
# Classification
#
# CONFIG_NET_CLS_BASIC is not set
# CONFIG_NET_CLS_TCINDEX is not set
# CONFIG_NET_CLS_ROUTE4 is not set
# CONFIG_NET_CLS_FW is not set
# CONFIG_NET_CLS_U32 is not set
# CONFIG_NET_CLS_RSVP is not set
# CONFIG_NET_CLS_RSVP6 is not set
# CONFIG_NET_EMATCH is not set
# CONFIG_NET_CLS_ACT is not set
CONFIG_NET_CLS_POLICE=y
CONFIG_NET_ESTIMATOR=y

#
# Network testing
#
# CONFIG_NET_PKTGEN is not set
# CONFIG_HAMRADIO is not set
# CONFIG_IRDA is not set
# CONFIG_BT is not set
# CONFIG_IEEE80211 is not set
CONFIG_WIRELESS_EXT=y
CONFIG_FIB_RULES=y

#
# Device Drivers
#

#
# Generic Driver Options
#
CONFIG_STANDALONE=y
CONFIG_PREVENT_FIRMWARE_BUILD=y
CONFIG_FW_LOADER=y
# CONFIG_SYS_HYPERVISOR is not set

#
# Connector - unified userspace <-> kernelspace linker
#
# CONFIG_CONNECTOR is not set

#
# Memory Technology Devices (MTD)
#
# CONFIG_MTD is not set

#
# Parallel port support
#
# CONFIG_PARPORT is not set

#
# Plug and Play support
#
# CONFIG_PNP is not set

#
# Block devices
#
# CONFIG_BLK_DEV_FD is not set
# CONFIG_BLK_DEV_XD is not set
# CONFIG_BLK_DEV_COW_COMMON is not set
CONFIG_BLK_DEV_LOOP=y
# CONFIG_BLK_DEV_CRYPTOLOOP is not set
# CONFIG_BLK_DEV_NBD is not set
CONFIG_BLK_DEV_RAM=y
CONFIG_BLK_DEV_RAM_COUNT=16
CONFIG_BLK_DEV_RAM_SIZE=4096
CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024
CONFIG_BLK_DEV_INITRD=y
# CONFIG_CDROM_PKTCDVD is not set
# CONFIG_ATA_OVER_ETH is not set

#
# Misc devices
#
# CONFIG_TIFM_CORE is not set

#
# ATA/ATAPI/MFM/RLL support
#
CONFIG_IDE=y
CONFIG_IDE_MAX_HWIFS=1
CONFIG_BLK_DEV_IDE=y

#
# Please see Documentation/ide.txt for help/info on IDE drives
#
# CONFIG_BLK_DEV_IDE_SATA is not set
# CONFIG_BLK_DEV_HD_IDE is not set
CONFIG_BLK_DEV_IDEDISK=y
CONFIG_IDEDISK_MULTI_MODE=y
# CONFIG_BLK_DEV_IDECD is not set
# CONFIG_BLK_DEV_IDETAPE is not set
# CONFIG_BLK_DEV_IDEFLOPPY is not set
# CONFIG_IDE_TASK_IOCTL is not set

#
# IDE chipset support/bugfixes
#
CONFIG_IDE_GENERIC=y
# CONFIG_BLK_DEV_CMD640 is not set
# CONFIG_IDE_ARM is not set
# CONFIG_IDE_CHIPSETS is not set
# CONFIG_BLK_DEV_IDEDMA is not set
# CONFIG_IDEDMA_AUTO is not set
# CONFIG_BLK_DEV_HD is not set

#
# SCSI device support
#
# CONFIG_RAID_ATTRS is not set
# CONFIG_SCSI is not set
# CONFIG_SCSI_NETLINK is not set

#
# Serial ATA (prod) and Parallel ATA (experimental) drivers
#
# CONFIG_ATA is not set

#
# Old CD-ROM drivers (not SCSI, not IDE)
#
# CONFIG_CD_NO_IDESCSI is not set

#
# Multi-device support (RAID and LVM)
#
# CONFIG_MD is not set

#
# Fusion MPT device support
#
# CONFIG_FUSION is not set

#
# IEEE 1394 (FireWire) support
#

#
# I2O device support
#

#
# Network device support
#
CONFIG_NETDEVICES=y
# CONFIG_DUMMY is not set
# CONFIG_BONDING is not set
# CONFIG_EQUALIZER is not set
# CONFIG_TUN is not set

#
# ARCnet devices
#
# CONFIG_ARCNET is not set

#
# PHY device support
#
# CONFIG_PHYLIB is not set

#
# Ethernet (10 or 100Mbit)
#
CONFIG_NET_ETHERNET=y
# CONFIG_MII is not set
CONFIG_NET_VENDOR_3COM=y
# CONFIG_EL1 is not set
# CONFIG_EL2 is not set
# CONFIG_ELPLUS is not set
# CONFIG_EL16 is not set
# CONFIG_EL3 is not set
# CONFIG_3C515 is not set
# CONFIG_LANCE is not set
CONFIG_NET_VENDOR_SMC=y
# CONFIG_WD80x3 is not set
# CONFIG_ULTRA is not set
# CONFIG_SMC9194 is not set
CONFIG_NET_VENDOR_RACAL=y
# CONFIG_NI5010 is not set
# CONFIG_NI52 is not set
# CONFIG_NI65 is not set
# CONFIG_AT1700 is not set
# CONFIG_DEPCA is not set
# CONFIG_HP100 is not set
CONFIG_NET_ISA=y
# CONFIG_E2100 is not set
# CONFIG_EWRK3 is not set
# CONFIG_EEXPRESS is not set
# CONFIG_EEXPRESS_PRO is not set
# CONFIG_HPLAN_PLUS is not set
# CONFIG_HPLAN is not set
# CONFIG_LP486E is not set
# CONFIG_ETH16I is not set
# CONFIG_NE2000 is not set
# CONFIG_ZNET is not set
# CONFIG_SEEQ8005 is not set
CONFIG_NET_PCI=y
# CONFIG_AC3200 is not set
# CONFIG_APRICOT is not set
# CONFIG_CS89x0 is not set

#
# Ethernet (1000 Mbit)
#

#
# Ethernet (10000 Mbit)
#

#
# Token Ring devices
#
# CONFIG_TR is not set

#
# Wireless LAN (non-hamradio)
#
CONFIG_NET_RADIO=y
# CONFIG_NET_WIRELESS_RTNETLINK is not set

#
# Obsolete Wireless cards support (pre-802.11)
#
# CONFIG_STRIP is not set
# CONFIG_ARLAN is not set
# CONFIG_WAVELAN is not set

#
# Wireless 802.11b ISA/PCI cards support
#
# CONFIG_HOSTAP is not set
CONFIG_NET_WIRELESS=y

#
# Wan interfaces
#
# CONFIG_WAN is not set
# CONFIG_PPP is not set
# CONFIG_SLIP is not set
# CONFIG_SHAPER is not set
# CONFIG_NETCONSOLE is not set
# CONFIG_NETPOLL is not set
# CONFIG_NET_POLL_CONTROLLER is not set

#
# ISDN subsystem
#
# CONFIG_ISDN is not set

#
# Telephony Support
#
# CONFIG_PHONE is not set

#
# Input device support
#
CONFIG_INPUT=y
# CONFIG_INPUT_FF_MEMLESS is not set

#
# Userland interfaces
#
# CONFIG_INPUT_MOUSEDEV is not set
# CONFIG_INPUT_JOYDEV is not set
# CONFIG_INPUT_TSDEV is not set
# CONFIG_INPUT_EVDEV is not set
# CONFIG_INPUT_EVBUG is not set

#
# Input Device Drivers
#
# CONFIG_INPUT_KEYBOARD is not set
# CONFIG_INPUT_MOUSE is not set
# CONFIG_INPUT_JOYSTICK is not set
# CONFIG_INPUT_TOUCHSCREEN is not set
# CONFIG_INPUT_MISC is not set

#
# Hardware I/O ports
#
# CONFIG_SERIO is not set
# CONFIG_GAMEPORT is not set

#
# Character devices
#
CONFIG_VT=y
CONFIG_VT_CONSOLE=y
CONFIG_HW_CONSOLE=y
# CONFIG_VT_HW_CONSOLE_BINDING is not set
# CONFIG_SERIAL_NONSTANDARD is not set

#
# Serial drivers
#
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_8250_CONSOLE=y
CONFIG_SERIAL_8250_NR_UARTS=4
CONFIG_SERIAL_8250_RUNTIME_UARTS=4
CONFIG_SERIAL_8250_EXTENDED=y
# CONFIG_SERIAL_8250_MANY_PORTS is not set
# CONFIG_SERIAL_8250_SHARE_IRQ is not set
# CONFIG_SERIAL_8250_DETECT_IRQ is not set
CONFIG_SERIAL_8250_RSA=y

#
# Non-8250 serial port support
#
CONFIG_SERIAL_CORE=y
CONFIG_SERIAL_CORE_CONSOLE=y
CONFIG_UNIX98_PTYS=y
# CONFIG_LEGACY_PTYS is not set

#
# IPMI
#
# CONFIG_IPMI_HANDLER is not set

#
# Watchdog Cards
#
CONFIG_WATCHDOG=y
# CONFIG_WATCHDOG_NOWAYOUT is not set

#
# Watchdog Device Drivers
#
# CONFIG_SOFT_WATCHDOG is not set
# CONFIG_ACQUIRE_WDT is not set
# CONFIG_ADVANTECH_WDT is not set
# CONFIG_SC520_WDT is not set
# CONFIG_EUROTECH_WDT is not set
# CONFIG_IB700_WDT is not set
# CONFIG_IBMASR is not set
# CONFIG_WAFER_WDT is not set
# CONFIG_SC1200_WDT is not set
# CONFIG_PC87413_WDT is not set
# CONFIG_60XX_WDT is not set
# CONFIG_SBC8360_WDT is not set
# CONFIG_CPU5_WDT is not set
# CONFIG_SMSC37B787_WDT is not set
# CONFIG_W83627HF_WDT is not set
# CONFIG_W83697HF_WDT is not set
# CONFIG_W83877F_WDT is not set
# CONFIG_W83977F_WDT is not set
# CONFIG_MACHZ_WDT is not set
# CONFIG_SBC_EPX_C3_WATCHDOG is not set

#
# ISA-based Watchdog Cards
#
# CONFIG_PCWATCHDOG is not set
# CONFIG_MIXCOMWD is not set
# CONFIG_WDT is not set
# CONFIG_HW_RANDOM is not set
# CONFIG_NVRAM is not set
CONFIG_RTC=y
# CONFIG_DTLK is not set
# CONFIG_R3964 is not set
# CONFIG_MWAVE is not set
# CONFIG_PC8736x_GPIO is not set
# CONFIG_NSC_GPIO is not set
# CONFIG_CS5535_GPIO is not set
# CONFIG_RAW_DRIVER is not set
# CONFIG_HANGCHECK_TIMER is not set

#
# TPM devices
#
# CONFIG_TCG_TPM is not set
# CONFIG_TELCLOCK is not set
CONFIG_JSCLIPBOARD=y

#
# I2C support
#
# CONFIG_I2C is not set

#
# SPI support
#
# CONFIG_SPI is not set
# CONFIG_SPI_MASTER is not set

#
# Dallas's 1-wire bus
#
# CONFIG_W1 is not set

#
# Hardware Monitoring support
#
# CONFIG_HWMON is not set
# CONFIG_HWMON_VID is not set

#
# Multimedia devices
#
# CONFIG_VIDEO_DEV is not set

#
# Digital Video Broadcasting Devices
#
# CONFIG_DVB is not set

#
# Graphics support
#
# CONFIG_FIRMWARE_EDID is not set
# CONFIG_FB is not set

#
# Console display driver support
#
# CONFIG_VGA_CONSOLE is not set
# CONFIG_MDA_CONSOLE is not set
CONFIG_DUMMY_CONSOLE=y
# CONFIG_BACKLIGHT_LCD_SUPPORT is not set

#
# Sound
#
# CONFIG_SOUND is not set

#
# HID Devices
#
# CONFIG_HID is not set

#
# USB support
#
# CONFIG_USB_ARCH_HAS_HCD is not set
# CONFIG_USB_ARCH_HAS_OHCI is not set
# CONFIG_USB_ARCH_HAS_EHCI is not set

#
# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
#

#
# USB Gadget Support
#
# CONFIG_USB_GADGET is not set

#
# MMC/SD Card support
#
# CONFIG_MMC is not set

#
# LED devices
#
# CONFIG_NEW_LEDS is not set

#
# LED drivers
#

#
# LED Triggers
#

#
# InfiniBand support
#

#
# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
#
# CONFIG_EDAC is not set

#
# Real Time Clock
#
# CONFIG_RTC_CLASS is not set

#
# DMA Engine support
#
# CONFIG_DMA_ENGINE is not set

#
# DMA Clients
#

#
# DMA Devices
#

#
# Virtualization
#
# CONFIG_KVM is not set

#
# File systems
#
CONFIG_EXT2_FS=y
CONFIG_EXT2_FS_XATTR=y
CONFIG_EXT2_FS_POSIX_ACL=y
CONFIG_EXT2_FS_SECURITY=y
# CONFIG_EXT2_FS_XIP is not set
# CONFIG_EXT3_FS is not set
# CONFIG_EXT4DEV_FS is not set
CONFIG_FS_MBCACHE=y
# CONFIG_REISERFS_FS is not set
# CONFIG_JFS_FS is not set
CONFIG_FS_POSIX_ACL=y
# CONFIG_XFS_FS is not set
# CONFIG_GFS2_FS is not set
# CONFIG_OCFS2_FS is not set
# CONFIG_MINIX_FS is not set
# CONFIG_ROMFS_FS is not set
# CONFIG_INOTIFY is not set
# CONFIG_QUOTA is not set
# CONFIG_DNOTIFY is not set
# CONFIG_AUTOFS_FS is not set
# CONFIG_AUTOFS4_FS is not set
# CONFIG_FUSE_FS is not set

#
# CD-ROM/DVD Filesystems
#
# CONFIG_ISO9660_FS is not set
# CONFIG_UDF_FS is not set

#
# DOS/FAT/NT Filesystems
#
# CONFIG_MSDOS_FS is not set
# CONFIG_VFAT_FS is not set
# CONFIG_NTFS_FS is not set

#
# Pseudo filesystems
#
CONFIG_PROC_FS=y
CONFIG_PROC_KCORE=y
CONFIG_PROC_SYSCTL=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
# CONFIG_TMPFS_POSIX_ACL is not set
CONFIG_HUGETLBFS=y
CONFIG_HUGETLB_PAGE=y
CONFIG_RAMFS=y
# CONFIG_CONFIGFS_FS is not set

#
# Miscellaneous filesystems
#
# CONFIG_ADFS_FS is not set
# CONFIG_AFFS_FS is not set
# CONFIG_HFS_FS is not set
# CONFIG_HFSPLUS_FS is not set
# CONFIG_BEFS_FS is not set
# CONFIG_BFS_FS is not set
# CONFIG_EFS_FS is not set
# CONFIG_CRAMFS is not set
# CONFIG_VXFS_FS is not set
# CONFIG_HPFS_FS is not set
# CONFIG_QNX4FS_FS is not set
# CONFIG_SYSV_FS is not set
# CONFIG_UFS_FS is not set

#
# Network File Systems
#
# CONFIG_NFS_FS is not set
# CONFIG_NFSD is not set
# CONFIG_SMB_FS is not set
# CONFIG_CIFS is not set
# CONFIG_NCP_FS is not set
# CONFIG_CODA_FS is not set
# CONFIG_AFS_FS is not set
# CONFIG_9P_FS is not set

#
# Partition Types
#
# CONFIG_PARTITION_ADVANCED is not set
CONFIG_MSDOS_PARTITION=y

#
# Native Language Support
#
CONFIG_NLS=y
CONFIG_NLS_DEFAULT="utf8"
CONFIG_NLS_CODEPAGE_437=y
# CONFIG_NLS_CODEPAGE_737 is not set
# CONFIG_NLS_CODEPAGE_775 is not set
# CONFIG_NLS_CODEPAGE_850 is not set
# CONFIG_NLS_CODEPAGE_852 is not set
# CONFIG_NLS_CODEPAGE_855 is not set
# CONFIG_NLS_CODEPAGE_857 is not set
# CONFIG_NLS_CODEPAGE_860 is not set
# CONFIG_NLS_CODEPAGE_861 is not set
# CONFIG_NLS_CODEPAGE_862 is not set
# CONFIG_NLS_CODEPAGE_863 is not set
# CONFIG_NLS_CODEPAGE_864 is not set
# CONFIG_NLS_CODEPAGE_865 is not set
# CONFIG_NLS_CODEPAGE_866 is not set
# CONFIG_NLS_CODEPAGE_869 is not set
# CONFIG_NLS_CODEPAGE_936 is not set
# CONFIG_NLS_CODEPAGE_950 is not set
# CONFIG_NLS_CODEPAGE_932 is not set
# CONFIG_NLS_CODEPAGE_949 is not set
# CONFIG_NLS_CODEPAGE_874 is not set
# CONFIG_NLS_ISO8859_8 is not set
# CONFIG_NLS_CODEPAGE_1250 is not set
# CONFIG_NLS_CODEPAGE_1251 is not set
CONFIG_NLS_ASCII=y
# CONFIG_NLS_ISO8859_1 is not set
# CONFIG_NLS_ISO8859_2 is not set
# CONFIG_NLS_ISO8859_3 is not set
# CONFIG_NLS_ISO8859_4 is not set
# CONFIG_NLS_ISO8859_5 is not set
# CONFIG_NLS_ISO8859_6 is not set
# CONFIG_NLS_ISO8859_7 is not set
# CONFIG_NLS_ISO8859_9 is not set
# CONFIG_NLS_ISO8859_13 is not set
# CONFIG_NLS_ISO8859_14 is not set
# CONFIG_NLS_ISO8859_15 is not set
# CONFIG_NLS_KOI8_R is not set
# CONFIG_NLS_KOI8_U is not set
# CONFIG_NLS_UTF8 is not set

#
# Distributed Lock Manager
#
# CONFIG_DLM is not set

#
# Instrumentation Support
#
# CONFIG_PROFILING is not set

#
# Kernel hacking
#
CONFIG_TRACE_IRQFLAGS_SUPPORT=y
# CONFIG_PRINTK_TIME is not set
CONFIG_ENABLE_MUST_CHECK=y
# CONFIG_MAGIC_SYSRQ is not set
CONFIG_UNUSED_SYMBOLS=y
# CONFIG_DEBUG_FS is not set
# CONFIG_HEADERS_CHECK is not set
# CONFIG_DEBUG_KERNEL is not set
CONFIG_LOG_BUF_SHIFT=14
# CONFIG_DEBUG_BUGVERBOSE is not set
CONFIG_EARLY_PRINTK=y
CONFIG_DOUBLEFAULT=y

#
# Security options
#
# CONFIG_KEYS is not set
# CONFIG_SECURITY is not set

#
# Cryptographic options
#
# CONFIG_CRYPTO is not set

#
# Library routines
#
CONFIG_BITREVERSE=y
CONFIG_CRC_CCITT=y
# CONFIG_CRC16 is not set
CONFIG_CRC32=y
# CONFIG_LIBCRC32C is not set
CONFIG_PLIST=y
CONFIG_IOMAP_COPY=y
CONFIG_GENERIC_HARDIRQS=y
CONFIG_GENERIC_IRQ_PROBE=y
CONFIG_X86_BIOS_REBOOT=y
CONFIG_KTIME_SCALAR=y
tmp/linuxstart-20120111/patch_linux-2.6.200000640000076400001440000001465311703377274017314 0ustar  bellardusersdiff -ruN linux-2.6.20.org/drivers/char/Kconfig linux-2.6.20/drivers/char/Kconfig
--- linux-2.6.20.org/drivers/char/Kconfig	2007-02-04 19:44:54.000000000 +0100
+++ linux-2.6.20/drivers/char/Kconfig	2011-05-18 20:06:45.000000000 +0200
@@ -1030,5 +1030,11 @@
 	  sysfs directory, /sys/devices/platform/telco_clock, with a number of
 	  files for controlling the behavior of this hardware.
 
+config JSCLIPBOARD
+	tristate "Javascript clipboard support (JS/Linux device)"
+	default n
+	help
+	  Javascript clipboard support for JS/Linux
+
 endmenu
 
diff -ruN linux-2.6.20.org/drivers/char/Makefile linux-2.6.20/drivers/char/Makefile
--- linux-2.6.20.org/drivers/char/Makefile	2007-02-04 19:44:54.000000000 +0100
+++ linux-2.6.20/drivers/char/Makefile	2011-05-18 20:07:13.000000000 +0200
@@ -100,6 +100,7 @@
 
 obj-$(CONFIG_HANGCHECK_TIMER)	+= hangcheck-timer.o
 obj-$(CONFIG_TCG_TPM)		+= tpm/
+obj-$(CONFIG_JSCLIPBOARD)	+= jsclipboard.o
 
 # Files generated that shall be removed upon make clean
 clean-files := consolemap_deftbl.c defkeymap.c
diff -ruN linux-2.6.20.org/drivers/char/jsclipboard.c linux-2.6.20/drivers/char/jsclipboard.c
--- linux-2.6.20.org/drivers/char/jsclipboard.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.20/drivers/char/jsclipboard.c	2011-05-18 21:36:11.000000000 +0200
@@ -0,0 +1,174 @@
+/* 
+   JS clipboard support for JS/Linux
+   (c) 2011 Fabrice Bellard
+*/
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/ioport.h>
+#include <linux/fcntl.h>
+#include <linux/mc146818rtc.h>
+#include <linux/init.h>
+#include <linux/poll.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/spinlock.h>
+#include <linux/sysctl.h>
+#include <linux/wait.h>
+#include <linux/bcd.h>
+#include <linux/delay.h>
+
+#include <asm/current.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+
+#define JSCLIPBOARD_MINOR 231
+
+#define JSCLIPBOARD_PORT 0x3c0
+
+static int io_port = JSCLIPBOARD_PORT;
+static int minor = JSCLIPBOARD_MINOR;
+static struct semaphore open_sem;
+static int need_cache_sync;
+
+module_param(io_port, int, 0);
+MODULE_PARM_DESC(io_port, "IO port");
+
+module_param(minor, int, 0);
+MODULE_PARM_DESC(minor, "minor number");
+
+static ssize_t jsclipboard_read(struct file *file, char __user *buf,
+                                size_t count1, loff_t *ppos)
+{
+        uint32_t pos, total_length, v;
+        uint8_t b;
+        size_t count, l;
+        
+        /* set read position */
+        pos = *ppos;
+        outl(pos, io_port + 4);
+        total_length = inl(io_port + 0);
+        
+        if (!access_ok(VERIFY_WRITE, buf, count1))
+                return -EFAULT;
+        
+        if (pos < total_length) 
+                l = total_length - pos;
+        else
+                l = 0;
+        if (count1 > l)
+                count1 = l;
+        count = count1;
+        while (count >= 4) {
+                v = inl(io_port + 8);
+                if (__put_user(v, (uint32_t *)buf))
+                        return -EFAULT;
+                buf += 4;
+                count -= 4;
+        }
+        
+        while (count != 0) {
+                b = inb(io_port + 8);
+                if (__put_user(b, buf))
+                        return -EFAULT;
+                buf++;
+                count--;
+        }
+
+        *ppos = pos + count1;
+
+        return count1;
+}
+
+static ssize_t jsclipboard_write(struct file *file, const char *buf, 
+                                 size_t count1, loff_t *ppos)
+{
+        size_t count;
+        uint8_t b;
+        uint32_t v;
+
+        if (!access_ok(VERIFY_READ, buf, count1))
+                return -EFAULT;
+        if (*ppos == 0) {
+                /* flush clipboard */
+                outl(0, io_port);
+        }
+
+        need_cache_sync = 1;
+
+        count = count1;
+        while (count >= 4) {
+                if (__get_user(v, (uint32_t *)buf))
+                        return -EFAULT;
+                outl(v, io_port + 8);
+                buf += 4;
+                count -= 4;
+        }
+
+        while (count != 0) {
+                if (__get_user(b, buf))
+                        return -EFAULT;
+                outb(b, io_port + 8);
+                buf++;
+                count--;
+        }
+        *ppos += count1;
+        return count1;
+}
+
+static int jsclipboard_open(struct inode *inode, struct file *file)
+{
+	if (down_trylock(&open_sem))
+		return -EBUSY;
+        need_cache_sync = 0;
+	return 0;
+}
+
+static int jsclipboard_release(struct inode *inode, struct file *file)
+{
+        if (need_cache_sync) {
+                outl(0, io_port + 12);
+        }
+	up(&open_sem);
+	return 0;
+}
+
+static const struct file_operations jsclipboard_fops = {
+	.owner		= THIS_MODULE,
+	.read		= jsclipboard_read,
+	.write		= jsclipboard_write,
+	.open		= jsclipboard_open,
+        .release        = jsclipboard_release,
+};
+
+static struct miscdevice jsclipboard_dev = {
+	.minor		= JSCLIPBOARD_MINOR,
+	.name		= "jsclipboard",
+	.fops		= &jsclipboard_fops,
+};
+
+static int __init jsclipboard_init(void)
+{
+        if (!request_region(io_port, 16, "jsclipboard")) 
+                return -ENODEV;
+	sema_init(&open_sem, 1);
+	if (misc_register(&jsclipboard_dev)) {
+                return -ENODEV;
+	}
+	printk(KERN_INFO "JS clipboard: I/O at 0x%04x\n", io_port);
+	return 0;
+}
+
+static void __exit jsclipboard_exit (void)
+{
+	misc_deregister(&jsclipboard_dev);
+        release_region(io_port, 16);
+}
+
+module_init(jsclipboard_init);
+module_exit(jsclipboard_exit);
+
+MODULE_AUTHOR("Fabrice Bellard");
+MODULE_LICENSE("GPL");
diff -ruN linux-2.6.20.org/drivers/serial/8250.c linux-2.6.20/drivers/serial/8250.c
--- linux-2.6.20.org/drivers/serial/8250.c	2007-02-04 19:44:54.000000000 +0100
+++ linux-2.6.20/drivers/serial/8250.c	2011-05-11 16:54:55.000000000 +0200
@@ -70,7 +70,8 @@
 #define DEBUG_INTR(fmt...)	do { } while (0)
 #endif
 
-#define PASS_LIMIT	256
+//#define PASS_LIMIT	256
+#define PASS_LIMIT	(256 * 100)
 
 /*
  * We default to IRQ0 for the "no irq" hack.   Some
--- linux-2.6.20.org/drivers/ide/ide-probe.c	2007-02-04 19:44:54.000000000 +0100
+++ linux-2.6.20/drivers/ide/ide-probe.c	2012-01-11 22:26:08.000000000 +0100
@@ -869,6 +869,8 @@
 			drive->no_io_32bit = 1;
 		else
 			drive->no_io_32bit = drive->id->dword_io ? 1 : 0;
+                /* force 32 bit I/O so that boot time is a little faster */
+                drive->io_32bit = 1;
 	}
 }
 
tmp/linuxstart-20120111/README0000640000076400001440000000072511703377274015203 0ustar  bellardusersThis directory contains the code necessary to build the Linux starter
for the JS PC emulator.

config_linux-2.6.20 contains the Linux kernel configuration
patch_linux-2.6.20 contains the Linux kernel patch

The 'kernel' target of the Makefile shows how to build the
vmlinux26.bin uncompressed kernel image.

show_boot_time.c is the program which displays the boot time (compiled
with uClibc).

Changelog:
---------

May 23, 2001:

- allow more recent kernels to boot.

tmp/linuxstart-20120111/libc.c0000640000076400001440000001511111703377274015373 0ustar  bellardusers/*
 * Copyright (c) 2011 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "libc.h"

#ifdef TEST
void putchar(int c);
#else

#define SERIAL_BASE 0x3f8
 
static void putchar1(int c)
{
    asm volatile("out %%al, %%dx" : : "a" (c), "d" (SERIAL_BASE));
}

void putchar(int c)
{
    if (c == '\n')
        putchar1('\r');
    putchar1(c);
}

void __attribute__((noreturn)) exit(int val)
{
    /* send reset command to the keyboard controller */
    asm volatile("out %%al, %%dx" : : "a" (0xfe), "d" (0x64));
    while (1);
}
#endif /* !TEST */

void put_string(const char *s)
{
    while (*s)
        putchar(*s++);
}

void put_int(unsigned int v)
{
    static const char hexchars[] = "0123456789abcdef";
    putchar(hexchars[(v >> 28) & 0xf]);
    putchar(hexchars[(v >> 24) & 0xf]);
    putchar(hexchars[(v >> 20) & 0xf]);
    putchar(hexchars[(v >> 16) & 0xf]);
    putchar(hexchars[(v >> 12) & 0xf]);
    putchar(hexchars[(v >> 8) & 0xf]);
    putchar(hexchars[(v >> 4) & 0xf]);
    putchar(hexchars[(v >> 0) & 0xf]);
}

void *memset(void *d1, int val, size_t len)
{
    uint8_t *d = d1;

    while (len--) {
        *d++ = val;
    }
    return d1;
}

void *memcpy(void *d1, const void *s1, size_t len)
{
    uint8_t *d = d1;
    const uint8_t *s = s1;

    while (len--) {
        *d++ = *s++;
    }
    return d1;
}

void *memmove(void *d1, const void *s1, size_t len)
{
    uint8_t *d = d1;
    const uint8_t *s = s1;

    if (d <= s) {
        while (len--) {
            *d++ = *s++;
        }
    } else {
        d += len;
        s += len;
        while (len--) {
            *--d = *--s;
        }
    }
    return d1;
}

size_t strlen(const char *s)
{
    const char *s1;
    for(s1 = s; *s1 != '\0'; s1++);
    return s1 - s;
}

char *strcpy(char *d, char *s)
{
    memcpy(d, s, strlen(s) + 1);
    return d;
}

static inline int mon_isdigit(int c)
{
    return c >= '0' && c <= '9';
}

#define OUTCHAR(c)	(buflen > 0? (--buflen, *buf++ = (c)): 0)

/* from BSD ppp sources */
int vsnprintf(char *buf, int buflen, const char *fmt, va_list args)
{
    int c, n;
    int width, prec, fillch;
    int base, len, neg, is_long;
    unsigned long val = 0;
    const char *f;
    char *str, *buf0;
    char num[32];
    static const char hexchars[] = "0123456789abcdef";

    buf0 = buf;
    --buflen;
    while (buflen > 0) {
	for (f = fmt; *f != '%' && *f != 0; ++f) 
            ;
	if (f > fmt) {
	    len = f - fmt;
	    if (len > buflen)
		len = buflen;
	    memcpy(buf, fmt, len);
	    buf += len;
	    buflen -= len;
	    fmt = f;
	}
	if (*fmt == 0)
	    break;
	c = *++fmt;
	width = prec = 0;
	fillch = ' ';
	if (c == '0') {
	    fillch = '0';
	    c = *++fmt;
	}
	if (c == '*') {
	    width = va_arg(args, int);
	    c = *++fmt;
	} else {
	    while (mon_isdigit(c)) {
		width = width * 10 + c - '0';
		c = *++fmt;
	    }
	}
	if (c == '.') {
	    c = *++fmt;
	    if (c == '*') {
		prec = va_arg(args, int);
		c = *++fmt;
	    } else {
		while (mon_isdigit(c)) {
		    prec = prec * 10 + c - '0';
		    c = *++fmt;
		}
	    }
	}
        /* modifiers */
        is_long = 0;
        switch(c) {
        case 'l':
            is_long = 1;
            c = *++fmt;
            break;
        default:
            break;
        }
        str = 0;
	base = 0;
	neg = 0;
	++fmt;
	switch (c) {
	case 'd':
            if (is_long)
                val = va_arg(args, long);
            else
                val = va_arg(args, int);
	    if ((long)val < 0) {
		neg = 1;
		val = -val;
            }
	    base = 10;
	    break;
	case 'o':
            if (is_long)
                val = va_arg(args, unsigned long);
            else
                val = va_arg(args, unsigned int);
	    base = 8;
	    break;
	case 'x':
	case 'X':
            if (is_long)
                val = va_arg(args, unsigned long);
            else
                val = va_arg(args, unsigned int);
	    base = 16;
	    break;
	case 'p':
	    val = (unsigned long) va_arg(args, void *);
	    base = 16;
	    neg = 2;
	    break;
	case 's':
	    str = va_arg(args, char *);
	    break;
	case 'c':
	    num[0] = va_arg(args, int);
	    num[1] = 0;
	    str = num;
	    break;
	default:
	    *buf++ = '%';
	    if (c != '%')
		--fmt;		/* so %z outputs %z etc. */
	    --buflen;
	    continue;
	}
	if (base != 0) {
	    str = num + sizeof(num);
	    *--str = 0;
	    while (str > num + neg) {
		*--str = hexchars[val % base];
		val = val / base;
		if (--prec <= 0 && val == 0)
		    break;
	    }
	    switch (neg) {
	    case 1:
		*--str = '-';
		break;
	    case 2:
		*--str = 'x';
		*--str = '0';
		break;
	    }
	    len = num + sizeof(num) - 1 - str;
	} else {
	    len = strlen(str);
	    if (prec > 0 && len > prec)
		len = prec;
	}
	if (width > 0) {
	    if (width > buflen)
		width = buflen;
	    if ((n = width - len) > 0) {
		buflen -= n;
		for (; n > 0; --n)
		    *buf++ = fillch;
	    }
	}
	if (len > buflen)
	    len = buflen;
	memcpy(buf, str, len);
	buf += len;
	buflen -= len;
    }
    *buf = 0;
    return buf - buf0;
}

void __attribute((format (printf, 1, 2))) printf(const char *fmt, ...)
{
    char buf[1024];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, sizeof(buf), fmt, ap);
    put_string(buf);
    va_end(ap);
}

static uint8_t *malloc_ptr = NULL;
extern uint8_t _edata;

#define MALLOC_ALIGN 8

void *malloc(size_t size)
{
    void *ptr;

    if (!malloc_ptr) {
        malloc_ptr = &_edata;
        malloc_ptr = (void *)(((uintptr_t)malloc_ptr + MALLOC_ALIGN - 1) & ~(MALLOC_ALIGN - 1));
    }
    ptr = malloc_ptr;
    malloc_ptr = (void *)(((uintptr_t)malloc_ptr + size + MALLOC_ALIGN - 1) & ~(MALLOC_ALIGN - 1));
    return ptr;
}

void free(void *ptr)
{
}
tmp/linuxstart-20120111/show_boot_time.c0000644000076400001440000000271711703377274017517 0ustar  bellardusers/*
 * JS/Linux boot time display
 *
 * Copyright (c) 2011 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include <stdlib.h>
#include <stdio.h>
#include <sys/io.h>
#include <inttypes.h>

int main(int argc, char **argv)
{
    uint32_t boot_time;

    iopl(3); /* allow I/O port access (root only) */

    boot_time = inl(0x3cc);
    printf("Booted in %d.%03d s\n",
           boot_time / 1000,
           boot_time % 1000);
    return 0;
}
tmp/linuxstart-20120111/Makefile0000640000076400001440000000114411703377274015757 0ustar  bellardusersLD=ld -m elf_i386
CC=gcc -m32
CFLAGS= -O2 -Wall -fno-builtin -fno-stack-protector #-march=i386 
HOST_CFLAGS=-O2 -Wall
# modify to set the kernel path
KERNEL_PATH=../linux-2.6.20

all: linuxstart.bin

linuxstart.out: linuxstart_head.o linuxstart.o libc.o
	$(LD) -o $@ -N -Ttext 0x00010000 $^

linuxstart.bin: linuxstart.out
	objcopy -O binary $< $@

%.o: %.c
	$(CC) $(CFLAGS)  -c -o $@ $<

%.o: %.S
	$(CC) -m32 -D__ASSEMBLY__ -c -o $@ $<

# target to generate kernel
kernel:
	make -C $(KERNEL_PATH) -j4
	objcopy -O binary $(KERNEL_PATH)/vmlinux vmlinux26.bin

clean:
	rm -f linuxstart.bin linuxstart.out *.o *~ 

tmp/linuxstart-20120111/libc.h0000640000076400001440000000526011703377274015404 0ustar  bellardusers/*
 * Copyright (c) 2011 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include <stddef.h>
#include <stdarg.h>

#ifdef TEST
#include <stdlib.h>
#include <inttypes.h>
#else

typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
#if defined (__x86_64__)
typedef unsigned long uint64_t;
#else
typedef unsigned long long uint64_t;
#endif

typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
#if defined (__x86_64__)
typedef signed long int64_t;
#else
typedef signed long long int64_t;
#endif

#if defined (__x86_64__)
typedef uint64_t uintptr_t;
typedef int64_t intptr_t;
#else
typedef uint32_t uintptr_t;
typedef int32_t intptr_t;
#endif

#ifndef NULL
#define NULL 0
#endif

void *memset(void *d1, int val, size_t len);
void *memcpy(void *d1, const void *s1, size_t len);
void *memmove(void *d1, const void *s1, size_t len);
size_t strlen(const char *s);
char *strcpy(char *d, char *s);

void putchar(int c);
void __attribute__((noreturn)) exit(int val);
void *malloc(size_t size);
void free(void *ptr);
#endif /* !TEST */

void put_string(const char *s);
void put_int(unsigned int v);
int vsnprintf(char *buf, int buflen, const char *fmt, va_list args);
void __attribute((format (printf, 1, 2))) printf(const char *fmt, ...);

#define assert(a) \
    do {                                                            \
        if (!(a)) {                                                 \
            printf("%s:%d:" #a "\n", __FILE__, __LINE__);           \
            exit(1);                                                \
        }                                                           \
    } while (0)

tmp/linuxstart-20120111/runcom.c0000644000076400001440000006356611703377274016012 0ustar  bellardusers/*
 * Simple example of use of vm86: launch a basic .com DOS executable
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <signal.h>
#include <errno.h>
#include <ctype.h>

#include <sys/syscall.h>
#include <asm/vm86.h>

//#define SIGTEST
//#define DUMP_INT21

static inline int vm86(int func, struct vm86plus_struct *v86)
{
    return syscall(__NR_vm86, func, v86);
}

#define TF_MASK 		0x00000100
#define IF_MASK 		0x00000200
#define DF_MASK 		0x00000400
#define IOPL_MASK		0x00003000
#define NT_MASK	         	0x00004000
#define RF_MASK			0x00010000
#define VM_MASK			0x00020000
#define AC_MASK			0x00040000
#define VIF_MASK                0x00080000
#define VIP_MASK                0x00100000
#define ID_MASK                 0x00200000

void usage(void)
{
    printf("runcom version 0.2 (c) 2003-2011 Fabrice Bellard\n"
           "usage: runcom file.com [args...]\n"
           "Run simple .com DOS executables (linux vm86 test mode)\n");
    exit(1);
}

static inline void set_bit(uint8_t *a, unsigned int bit)
{
    a[bit / 8] |= (1 << (bit % 8));
}

static inline uint8_t *seg_to_linear(unsigned int seg, unsigned int reg)
{
    return (uint8_t *)((seg << 4) + (reg & 0xffff));
}

static inline void pushw(struct vm86_regs *r, int val)
{
    r->esp = (r->esp & ~0xffff) | ((r->esp - 2) & 0xffff);
    *(uint16_t *)seg_to_linear(r->ss, r->esp) = val;
}

void dump_regs(struct vm86_regs *r)
{
    fprintf(stderr,
            "EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx\n"
            "ESI=%08lx EDI=%08lx EBP=%08lx ESP=%08lx\n"
            "EIP=%08lx EFL=%08lx\n"
            "CS=%04x DS=%04x ES=%04x SS=%04x FS=%04x GS=%04x\n",
            r->eax, r->ebx, r->ecx, r->edx, r->esi, r->edi, r->ebp, r->esp,
            r->eip, r->eflags,
            r->cs, r->ds, r->es, r->ss, r->fs, r->gs);
}

#ifdef SIGTEST
void alarm_handler(int sig)
{
    fprintf(stderr, "alarm signal=%d\n", sig);
    alarm(1);
}
#endif

#define DOS_FD_MAX 256
typedef struct {
    int fd; /* -1 means closed */
} DOSFile;

DOSFile dos_files[DOS_FD_MAX];
uint16_t cur_psp;

void dos_init(void)
{
    int i;
    for(i = 0; i < 3; i++)
        dos_files[i].fd = i;    
    for(i = 3; i < DOS_FD_MAX; i++)
        dos_files[i].fd = -1;
}

static inline void set_error(struct vm86_regs *r, int val)
{
    if (val) {
        r->eax = (r->eax & ~0xffff) | val;
        r->eflags |= 1;
    } else {
        r->eflags &= ~1;
    }
}
static DOSFile *get_file(int h)
{
    DOSFile *fh;

    if (h >= DOS_FD_MAX)
        return NULL;
    fh = &dos_files[h];
    if (fh->fd == -1)
        return NULL;
    return fh;
}

/* return -1 if error */
static int get_new_handle(void)
{
    DOSFile *fh;
    int i;

    for(i = 0; i < DOS_FD_MAX; i++) {
        fh = &dos_files[i];
        if (fh->fd == -1)
            return i;
    }
    return -1;
}

static char *get_filename1(struct vm86_regs *r, char *buf, int buf_size,
                           uint16_t seg, uint16_t offset)
{
    char *q;
    int c;
    q = buf;
    for(;;) {
        c = *seg_to_linear(seg, offset);
        if (c == 0)
            break;
        if (q >= buf + buf_size - 1)
            break;
        c = tolower(c);
        if (c == '\\')
            c = '/';
        *q++ = c;
        offset++;
    }
    *q = '\0';
    return buf;
} 

static char *get_filename(struct vm86_regs *r, char *buf, int buf_size)
{
    return get_filename1(r, buf, buf_size, r->ds, r->edx & 0xffff);
}

typedef struct __attribute__((packed)) {
    uint8_t drive_num;
    uint8_t file_name[8];
    uint8_t file_ext[3];
    uint16_t current_block;
    uint16_t logical_record_size;
    uint32_t file_size;
    uint16_t date;
    uint16_t time;
    uint8_t reserved[8];
    uint8_t record_in_block;
    uint32_t record_num;
} FCB;

typedef struct __attribute__((packed)) {
    uint16_t environ;
    uint16_t cmdtail_off;
    uint16_t cmdtail_seg;
    uint32_t fcb1;
    uint32_t fcb2;
    uint16_t sp, ss;
    uint16_t ip, cs;
} ExecParamBlock;

typedef struct MemBlock {
    struct MemBlock *next;
    uint16_t seg;
    uint16_t size; /* in paragraphs */
} MemBlock;

/* first allocated paragraph */
MemBlock *first_mem_block = NULL;

#define MEM_START 0x1000
#define MEM_END   0xa000

/* return -1 if error */
int mem_malloc(int size, int *pmax_size)
{
    MemBlock *m, **pm;
    int seg_free, seg;
    
    /* XXX: this is totally inefficient, but we have only 1 or 2
       blocks ! */
    seg_free = MEM_START;
    for(pm = &first_mem_block; *pm != NULL; pm = &(*pm)->next) {
        m = *pm;
        seg = m->seg + m->size;
        if (seg > seg_free)
            seg_free = seg;
    }
    if ((seg_free + size) > MEM_END)
        return -1;
    if (pmax_size)
        *pmax_size = MEM_END - seg_free;
    /* add at the end */
    m = malloc(sizeof(MemBlock));
    *pm = m;
    m->next = NULL;
    m->seg = seg_free;
    m->size = size;
#ifdef DUMP_INT21
    printf("mem_malloc size=0x%04x: 0x%04x\n", size, seg_free);
#endif
    return seg_free;
}

/* return -1 if error */
int mem_free(int seg)
{
    MemBlock *m, **pm;
    for(pm = &first_mem_block; *pm != NULL; pm = &(*pm)->next) {
        m = *pm;
        if (m->seg == seg) {
            *pm = m->next;
            free(m);
            return 0;
        }
    }
    return -1;
}

/* return -1 if error or the maxmium size */
int mem_resize(int seg, int new_size)
{
    MemBlock *m, **pm, *m1;
    int max_size;

    for(pm = &first_mem_block; *pm != NULL; pm = &(*pm)->next) {
        m = *pm;
        if (m->seg == seg) {
            m1 = m->next;
            if (!m1)
                max_size = MEM_END - m->seg;
            else
                max_size = m1->seg - m->seg;
            if (new_size > max_size)
                return -1;
            m->size = new_size;
            return max_size;
        }
    }
    return -1;
}

/* return the PSP or -1 if error */
int load_com(ExecParamBlock *blk, const char *filename, uint32_t *pfile_size,
             int initial_exec)
{
    int psp, fd, ret;

    /* load the MSDOS .com executable */
    fd = open(filename, O_RDONLY);
    if (fd < 0) {
        return -1;
    }
    psp = mem_malloc(65536 / 16, NULL);
    ret = read(fd, seg_to_linear(psp, 0x100), 65536 - 0x100);
    if (ret <= 0) {
        close(fd);
        mem_free(psp);
        return -1;
    }
    close(fd);
    
    /* reset the PSP */
    memset(seg_to_linear(psp, 0), 0, 0x100);

    *seg_to_linear(psp, 0) = 0xcd; /* int $0x20 */
    *seg_to_linear(psp, 1) = 0x20;
    /* address of last segment allocated */
    *(uint16_t *)seg_to_linear(psp, 2) = psp + 0xfff;

    /* push ax value */
    *(uint16_t *)seg_to_linear(psp, 0xfffc) = 0;
    /* push return address to 0 */
    *(uint16_t *)seg_to_linear(psp, 0xfffe) = 0;

    if (!initial_exec) {
        int len;
        /* copy the command line */
        len = *seg_to_linear(blk->cmdtail_seg, blk->cmdtail_off);
        memcpy(seg_to_linear(psp, 0x80), 
               seg_to_linear(blk->cmdtail_seg, blk->cmdtail_off), len + 2);
    }

    blk->sp = 0xfffc;
    blk->ip = 0x100;
    blk->cs = blk->ss = psp;
    if (pfile_size)
        *pfile_size = ret;
    return psp;
}


void do_int20(struct vm86_regs *r)
{
    /* terminate program */
    exit(0);
}

void do_int21(struct vm86_regs *r)
{
    uint8_t ah;
    
    ah = (r->eax >> 8) & 0xff;
    switch(ah) {
    case 0x00: /* exit */
        exit(0);
    case 0x02: /* write char */
        {
            uint8_t c = r->edx;
            write(1, &c, 1);
        }
        break;
    case 0x09: /* write string */
        {
            uint8_t c;
            int offset;
            offset = r->edx;
            for(;;) {
                c = *seg_to_linear(r->ds, offset & 0xffff);
                if (c == '$')
                    break;
                write(1, &c, 1);
                offset++;
            }
            r->eax = (r->eax & ~0xff) | '$';
        }
        break;
    case 0x0a: /* buffered input */
        {
            int max_len, cur_len, ret;
            uint8_t ch;
            uint16_t off;

            /* XXX: should use raw mode to avoid sending the CRLF to
               the terminal */
            off = r->edx & 0xffff;
            max_len = *seg_to_linear(r->ds, off);
            cur_len = 0;
            while (cur_len < max_len) {
                ret = read(0, &ch, 1);
                if (ret < 0) {
                    if (errno != EINTR && errno != EAGAIN)
                        break;
                } else if (ret == 0) {
                    break;
                } else {
                    if (ch == '\n')
                        break;
                }
                *seg_to_linear(r->ds, off + 2 + cur_len++) = ch;
            }
            *seg_to_linear(r->ds, off + 1) = cur_len;
            *seg_to_linear(r->ds, off + 2 + cur_len) = '\r';
        }
        break;
    case 0x25: /* set interrupt vector */
        {
            uint16_t *ptr;
            ptr = (uint16_t *)seg_to_linear(0, (r->eax & 0xff) * 4);
            ptr[0] = r->edx;
            ptr[1] = r->ds;
        }
        break;
    case 0x29: /* parse filename into FCB */
#if 0
        /* not really needed */
        {
            const uint8_t *p, *p_start;
            uint8_t file[8], ext[3]; 
            FCB *fcb;
            int file_len, ext_len, has_wildchars, c, drive_num;
            
            /* XXX: not complete at all */
            fcb = (FCB *)seg_to_linear(r->es, r->edi & 0xffff);
            printf("ds=0x%x si=0x%lx\n", r->ds, r->esi);
            p_start = (const uint8_t *)seg_to_linear(r->ds, r->esi & 0xffff);

            p = p_start;
            has_wildchars = 0;

            /* drive */
            if (isalpha(p[0]) && p[1] == ':') {
                drive_num = toupper(p[0]) - 'A' + 1;
                p += 2;
            } else {
                drive_num = 0;
            }

            /* filename */
            file_len = 0;
            for(;;) {
                c = *p;
                if (!(c >= 33 && c <= 126))
                    break;
                if (c == '.')
                    break;
                if (c == '*' || c == '?')
                    has_wildchars = 1;
                if (file_len < 8)
                    file[file_len++] = c;
            }
            memset(file + file_len, ' ', 8 - file_len);

            /* extension */
            ext_len = 0;
            if (*p == '.') {
                for(;;) {
                    c = *p;
                    if (!(c >= 33 && c <= 126))
                        break;
                    if (c == '*' || c == '?')
                        has_wildchars = 1;
                    ext[ext_len++] = c;
                    if (ext_len >= 3)
                        break;
                }
            }
            memset(ext + ext_len, ' ', 3 - ext_len);

#if 0
            {
                printf("drive=%d file=%8s ext=%3s\n",
                       drive_num, file, ext);
            }
#endif
            if (drive_num == 0 && r->eax & (1 << 1)) {
                /* keep drive */
            } else {
                fcb->drive_num = drive_num; /* default drive */
            }

            if (file_len == 0 && r->eax & (1 << 2)) {
                /* keep */
            } else {
                memcpy(fcb->file_name, file, 8);
            }

            if (ext_len == 0 && r->eax & (1 << 3)) {
                /* keep */
            } else {
                memcpy(fcb->file_ext, ext, 3);
            }
            r->eax = (r->eax & ~0xff) | has_wildchars;
            r->esi = (r->esi & ~0xffff) | ((r->esi + (p - p_start)) & 0xffff);
        }
#endif
        break;
    case 0x30: /* get dos version */
        {
            int major, minor, serial, oem;
            /* XXX: return correct value for FreeDOS */
            major = 0x03;
            minor = 0x31;
            serial = 0x123456;
            oem = 0x66;
            r->eax = (r->eax & ~0xffff) | major | (minor << 8);
            r->ecx = (r->ecx & ~0xffff) | (serial & 0xffff);
            r->ebx = (r->ebx & ~0xffff) | (serial & 0xff) | (0x66 << 8);
        }
        break;
    case 0x35: /* get interrupt vector */
        {
            uint16_t *ptr;
            ptr = (uint16_t *)seg_to_linear(0, (r->eax & 0xff) * 4);
            r->ebx = (r->ebx & ~0xffff) | ptr[0];
            r->es = ptr[1];
        }
        break;
    case 0x37: 
        {
            switch(r->eax & 0xff) {
            case 0x00: /* get switch char */
                r->eax = (r->eax & ~0xff) | 0x00;
                r->edx = (r->edx & ~0xff) | '/';
                break;
            default:
                goto unsupported;
            }
        }
        break;
    case 0x3c: /* create or truncate file */
        {
            char filename[1024];
            int fd, h, flags;

            h = get_new_handle();
            if (h < 0) {
                set_error(r, 0x04); /* too many open files */
            } else {
                get_filename(r, filename, sizeof(filename));
                if (r->ecx & 1)
                    flags = 0444; /* read-only */
                else
                    flags = 0777;
                fd = open(filename, O_RDWR | O_TRUNC | O_CREAT, flags);
#ifdef DUMP_INT21
                printf("int21: create: file='%s' cx=0x%04x ret=%d\n", 
                       filename, (int)(r->ecx & 0xffff), h);
#endif
                if (fd < 0) {
                    set_error(r, 0x03); /* path not found */
                } else {
                    dos_files[h].fd = fd;
                    set_error(r, 0);
                    r->eax = (r->eax & ~0xffff) | h;
                }
            }
        }
        break;
    case 0x3d: /* open file */
        {
            char filename[1024];
            int fd, h;

            h = get_new_handle();
            if (h < 0) {
                set_error(r, 0x04); /* too many open files */
            } else {
                get_filename(r, filename, sizeof(filename));
#ifdef DUMP_INT21
                printf("int21: open: file='%s' al=0x%02x ret=%d\n", 
                       filename, (int)(r->eax & 0xff), h);
#endif
                fd = open(filename, r->eax & 3);
                if (fd < 0) {
                    set_error(r, 0x02); /* file not found */
                } else {
                    dos_files[h].fd = fd;
                    set_error(r, 0);
                    r->eax = (r->eax & ~0xffff) | h;
                }
            }
        }
        break;
    case 0x3e: /* close file */
        {
            DOSFile *fh = get_file(r->ebx & 0xffff);
#ifdef DUMP_INT21
            printf("int21: close fd=%d\n", (int)(r->ebx & 0xffff));
#endif
            if (!fh) {
                set_error(r, 0x06); /* invalid handle */
            } else {
                close(fh->fd);
                fh->fd = -1;
                set_error(r, 0);
            }
        }
        break;
    case 0x3f: /* read */
        {
            DOSFile *fh = get_file(r->ebx & 0xffff);
            int n, ret;

            if (!fh) {
                set_error(r, 0x06); /* invalid handle */
            } else {
                n = r->ecx & 0xffff;
                for(;;) {
                    ret = read(fh->fd, 
                               seg_to_linear(r->ds, r->edx & 0xffff), n);
                    if (ret < 0) {
                        if (errno != EINTR && errno != EAGAIN)
                            break;
                    } else {
                        break;
                    }
                }
#ifdef DUMP_INT21
                printf("int21: read: fd=%d n=%d ret=%d\n", 
                       (int)(r->ebx & 0xffff), n, ret);
#endif
                if (ret < 0) {
                    set_error(r, 0x05); /* acces denied */
                } else {
                    r->eax = (r->eax & ~0xffff) | ret;
                    set_error(r, 0);
                }
            }
        }
        break;
    case 0x40: /* write */
        {
            DOSFile *fh = get_file(r->ebx & 0xffff);
            int n, ret, pos;
            
            if (!fh) {
                set_error(r, 0x06); /* invalid handle */
            } else {
                n = r->ecx & 0xffff;
                if (n == 0) {
                    /* truncate */
                    pos = lseek(fh->fd, 0, SEEK_CUR);
                    if (pos >= 0) {
                        ret = ftruncate(fh->fd, pos);
                    } else {
                        ret = -1;
                    }
                } else {
                    for(;;) {
                        ret = write(fh->fd, 
                                    seg_to_linear(r->ds, r->edx & 0xffff), n);
                        if (ret < 0) {
                            if (errno != EINTR && errno != EAGAIN)
                                break;
                        } else {
                            break;
                        }
                    }
                }
#ifdef DUMP_INT21
                printf("int21: write: fd=%d n=%d ret=%d\n", 
                       (int)(r->ebx & 0xffff), n, ret);
#endif
                if (ret < 0) {
                    set_error(r, 0x05); /* acces denied */
                } else {
                    r->eax = (r->eax & ~0xffff) | ret;
                    set_error(r, 0);
                }
            }
        }
        break;
    case 0x41: /* unlink */
        {
            char filename[1024];
            get_filename(r, filename, sizeof(filename));
            if (unlink(filename) < 0) {
                set_error(r, 0x02); /* file not found */
            } else {
                set_error(r, 0);
            }
        }
        break;
    case 0x42: /* lseek */
        {
            DOSFile *fh = get_file(r->ebx & 0xffff);
            int pos, ret;
            
            if (!fh) {
                set_error(r, 0x06); /* invalid handle */
            } else {
                pos = ((r->ecx & 0xffff) << 16) | (r->edx & 0xffff);
                ret = lseek(fh->fd, pos, r->eax & 0xff);
#ifdef DUMP_INT21
                printf("int21: lseek: fd=%d pos=%d whence=%d ret=%d\n", 
                       (int)(r->ebx & 0xffff), pos, (uint8_t)r->eax, ret);
#endif
                if (ret < 0) {
                    set_error(r, 0x01); /* function number invalid */
                } else {
                    r->edx = (r->edx & ~0xffff) | ((unsigned)ret >> 16);
                    r->eax = (r->eax & ~0xffff) | (ret & 0xffff);
                    set_error(r, 0);
                }
            }
        }
        break;
    case 0x44: /* ioctl */
        switch(r->eax & 0xff) {
        case 0x00: /* get device information */
            {
                DOSFile *fh = get_file(r->ebx & 0xffff);
                int ret;
                
                if (!fh) {
                    set_error(r, 0x06); /* invalid handle */
                } else {
                    ret = 0;
                    if (isatty(fh->fd)) {
                        ret |= 0x80;
                        if (fh->fd == 0)
                            ret |= (1 << 0);
                        else
                            ret |= (1 << 1);
                    }
                    r->edx = (r->edx & ~0xffff) | ret;
                    set_error(r, 0);
                }
            }
            break;
        default:
            goto unsupported;
        }
        break;
    case 0x48: /* allocate memory */
        {
            int ret, max_size;
#ifdef DUMP_INT21
            printf("int21: allocate memory: size=0x%04x\n", (uint16_t)r->ebx);
#endif
            ret = mem_malloc(r->ebx & 0xffff, &max_size);
            if (ret < 0) {
                set_error(r, 0x08); /* insufficient memory*/
            } else {
                r->eax = (r->eax & ~0xffff) | ret;
                r->ebx = (r->ebx & ~0xffff) | max_size;
                set_error(r, 0);
            }
        }
        break;
    case 0x49: /* free memory */
        {
#ifdef DUMP_INT21
            printf("int21: free memory: block=0x%04x\n", r->es);
#endif
            if (mem_free(r->es) < 0) {
                set_error(r, 0x09); /* memory block address invalid */
            } else {
                set_error(r, 0);
            }
        }
        break;
    case 0x4a: /* resize memory block */
        {
            int ret;
#ifdef DUMP_INT21
            printf("int21: resize memory block: block=0x%04x size=0x%04x\n", 
                   r->es, (uint16_t)r->ebx);
#endif
            ret = mem_resize(r->es, r->ebx & 0xffff);
            if (ret < 0) {
                set_error(r, 0x08); /* insufficient memory*/
            } else {
                r->ebx = (r->ebx & ~0xffff) | ret;
                set_error(r, 0);
            }
        }
        break;
    case 0x4b: /* load program */
        {
            char filename[1024];
            ExecParamBlock *blk;
            int ret;

            if ((r->eax & 0xff) != 0x01) /* only load */
                goto unsupported;
            get_filename(r, filename, sizeof(filename));
            blk = (ExecParamBlock *)seg_to_linear(r->es, r->ebx & 0xffff);
            ret = load_com(blk, filename, NULL, 0);
            if (ret < 0) {
                set_error(r, 0x02); /* file not found */
            } else {
                cur_psp = ret;
                set_error(r, 0);
            }
        }
        break;
    case 0x4c: /* exit with return code */
        exit(r->eax & 0xff);
        break;
    case 0x50: /* set PSP address */
#ifdef DUMP_INT21
        printf("int21: set PSP: 0x%04x\n", (uint16_t)r->ebx);
#endif
        cur_psp = r->ebx;
        break;
    case 0x51: /* get PSP address */
#ifdef DUMP_INT21
        printf("int21: get PSP: ret=0x%04x\n", cur_psp);
#endif
        r->ebx = (r->ebx & ~0xffff) | cur_psp;
        break;
    case 0x55: /* create child PSP */
        {
            uint8_t *psp_ptr;
#ifdef DUMP_INT21
            printf("int21: create child PSP: psp=0x%04x last_seg=0x%04x\n", 
                   (uint16_t)r->edx, (uint16_t)r->esi);
#endif
            psp_ptr = seg_to_linear(r->edx & 0xffff, 0);
            memset(psp_ptr, 0, 0x80);
            psp_ptr[0] = 0xcd; /* int $0x20 */
            psp_ptr[1] = 0x20;
            *(uint16_t *)(psp_ptr + 2) = r->esi;
            r->eax = (r->eax & ~0xff);
        }
        break;
    default:
    unsupported:
        fprintf(stderr, "int 0x%02x: unsupported function 0x%02x\n", 0x21, ah);
        dump_regs(r);
        set_error(r, 0x01); /* function number invalid */
        break;
    }
}
    
void do_int29(struct vm86_regs *r)
{
    uint8_t c = r->eax;
    write(1, &c, 1);
}

int main(int argc, char **argv)
{
    uint8_t *vm86_mem;
    const char *filename;
    int ret;
    uint32_t file_size;
    struct vm86plus_struct ctx;
    struct vm86_regs *r;
    ExecParamBlock blk1, *blk = &blk1;

    if (argc < 2)
        usage();
    filename = argv[1];

    vm86_mem = mmap((void *)0x00000000, 0x110000,
                    PROT_WRITE | PROT_READ | PROT_EXEC,
                    MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
    if (vm86_mem == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }
#ifdef SIGTEST
    {
        struct sigaction act;

        act.sa_handler = alarm_handler;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        sigaction(SIGALRM, &act, NULL);
        alarm(1);
    }
#endif

    memset(&ctx, 0, sizeof(ctx));
    r = &ctx.regs;
    set_bit((uint8_t *)&ctx.int_revectored, 0x20);
    set_bit((uint8_t *)&ctx.int_revectored, 0x21);
    set_bit((uint8_t *)&ctx.int_revectored, 0x29);

    dos_init();

    ret = load_com(blk, filename, &file_size, 1);
    if (ret < 0) {
        perror(filename);
        exit(1);
    }
    cur_psp = ret;

    /* init basic registers */
    r->eip = blk->ip;
    r->esp = blk->sp + 2; /* pop ax value */
    r->cs = cur_psp;
    r->ss = blk->ss;
    r->ds = cur_psp;
    r->es = cur_psp;
    r->eflags = VIF_MASK;
    
    /* set the command line */
    {
        int i, p;
        char *s;

        p = 0x81;
        for(i = 2; i < argc; i++) {
            if (p >= 0xff)
                break;
            *seg_to_linear(cur_psp, p++) = ' ';
            s = argv[i];
            while (*s) {
                if (p >= 0xff)
                    break;
                *seg_to_linear(cur_psp, p++) = *s++;
            }
        }
        *seg_to_linear(cur_psp, p) = '\r';
        *seg_to_linear(cur_psp, 0x80) = p - 0x81;
    }

    /* the value of these registers seem to be assumed by pi_10.com */
    r->esi = 0x100;
#if 0
    r->ebx = file_size >> 16;
    r->ecx = file_size & 0xffff;
#else
    r->ecx = 0xff;
#endif
    r->ebp = 0x0900;
    r->edi = 0xfffe;

    for(;;) {
        ret = vm86(VM86_ENTER, &ctx);
        switch(VM86_TYPE(ret)) {
        case VM86_INTx:
            {
                int int_num;

                int_num = VM86_ARG(ret);
                switch(int_num) {
                case 0x20:
                    do_int20(r);
                    break;
                case 0x21:
                    do_int21(r);
                    break;
                case 0x29:
                    do_int29(r);
                    break;
                default:
                    fprintf(stderr, "unsupported int 0x%02x\n", int_num);
                    dump_regs(&ctx.regs);
                    break;
                }
            }
            break;
        case VM86_SIGNAL:
            /* a signal came, we just ignore that */
            break;
        case VM86_STI:
            break;
        case VM86_TRAP:
            /* just executes the interruption */
            {
                uint16_t *int_vector;
                uint32_t eflags;
                
                eflags = r->eflags & ~IF_MASK;
                if (r->eflags & VIF_MASK)
                    eflags |= IF_MASK;
                pushw(r, eflags);
                pushw(r, r->cs);
                pushw(r, r->eip);
                int_vector = (uint16_t *)seg_to_linear(0, VM86_ARG(ret) * 4);
                r->eip = int_vector[0];
                r->cs = int_vector[1];
                r->eflags &= ~(VIF_MASK | TF_MASK | AC_MASK);
            }
            break;
        default:
            fprintf(stderr, "unhandled vm86 return code (0x%x)\n", ret);
            dump_regs(&ctx.regs);
            exit(1);
        }
    }
}
tmp/linuxstart-20120111/linuxstart.c0000640000076400001440000001576011703377274016711 0ustar  bellardusers/*
 * JS/Linux Linux starter
 *
 * Copyright (c) 2011 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "libc.h"
#include "linuxstart.h"

/* from plex86 (BSD license) */
struct  __attribute__ ((packed)) linux_params {
  // For 0x00..0x3f, see 'struct screen_info' in linux/include/linux/tty.h.
  // I just padded out the VESA parts, rather than define them.

  /* 0x000 */ uint8_t   orig_x;
  /* 0x001 */ uint8_t   orig_y;
  /* 0x002 */ uint16_t  ext_mem_k;
  /* 0x004 */ uint16_t  orig_video_page;
  /* 0x006 */ uint8_t   orig_video_mode;
  /* 0x007 */ uint8_t   orig_video_cols;
  /* 0x008 */ uint16_t  unused1;
  /* 0x00a */ uint16_t  orig_video_ega_bx;
  /* 0x00c */ uint16_t  unused2;
  /* 0x00e */ uint8_t   orig_video_lines;
  /* 0x00f */ uint8_t   orig_video_isVGA;
  /* 0x010 */ uint16_t  orig_video_points;
  /* 0x012 */ uint8_t   pad0[0x20 - 0x12]; // VESA info.
  /* 0x020 */ uint16_t  cl_magic;  // Commandline magic number (0xA33F)
  /* 0x022 */ uint16_t  cl_offset; // Commandline offset.  Address of commandline
                                 // is calculated as 0x90000 + cl_offset, bu
                                 // only if cl_magic == 0xA33F.
  /* 0x024 */ uint8_t   pad1[0x40 - 0x24]; // VESA info.

  /* 0x040 */ uint8_t   apm_bios_info[20]; // struct apm_bios_info
  /* 0x054 */ uint8_t   pad2[0x80 - 0x54];

  // Following 2 from 'struct drive_info_struct' in drivers/block/cciss.h.
  // Might be truncated?
  /* 0x080 */ uint8_t   hd0_info[16]; // hd0-disk-parameter from intvector 0x41
  /* 0x090 */ uint8_t   hd1_info[16]; // hd1-disk-parameter from intvector 0x46

  // System description table truncated to 16 bytes
  // From 'struct sys_desc_table_struct' in linux/arch/i386/kernel/setup.c.
  /* 0x0a0 */ uint16_t  sys_description_len;
  /* 0x0a2 */ uint8_t   sys_description_table[14];
                        // [0] machine id
                        // [1] machine submodel id
                        // [2] BIOS revision
                        // [3] bit1: MCA bus

  /* 0x0b0 */ uint8_t   pad3[0x1e0 - 0xb0];
  /* 0x1e0 */ uint32_t  alt_mem_k;
  /* 0x1e4 */ uint8_t   pad4[4];
  /* 0x1e8 */ uint8_t   e820map_entries;
  /* 0x1e9 */ uint8_t   eddbuf_entries; // EDD_NR
  /* 0x1ea */ uint8_t   pad5[0x1f1 - 0x1ea];
  /* 0x1f1 */ uint8_t   setup_sects; // size of setup.S, number of sectors
  /* 0x1f2 */ uint16_t  mount_root_rdonly; // MOUNT_ROOT_RDONLY (if !=0)
  /* 0x1f4 */ uint16_t  sys_size; // size of compressed kernel-part in the
                                // (b)zImage-file (in 16 byte units, rounded up)
  /* 0x1f6 */ uint16_t  swap_dev; // (unused AFAIK)
  /* 0x1f8 */ uint16_t  ramdisk_flags;
  /* 0x1fa */ uint16_t  vga_mode; // (old one)
  /* 0x1fc */ uint16_t  orig_root_dev; // (high=Major, low=minor)
  /* 0x1fe */ uint8_t   pad6[1];
  /* 0x1ff */ uint8_t   aux_device_info;
  /* 0x200 */ uint16_t  jump_setup; // Jump to start of setup code,
                                  // aka "reserved" field.
  /* 0x202 */ uint8_t   setup_signature[4]; // Signature for SETUP-header, ="HdrS"
  /* 0x206 */ uint16_t  header_format_version; // Version number of header format;
  /* 0x208 */ uint8_t   setup_S_temp0[8]; // Used by setup.S for communication with
                                        // boot loaders, look there.
  /* 0x210 */ uint8_t   loader_type;
                        // 0 for old one.
                        // else 0xTV:
                        //   T=0: LILO
                        //   T=1: Loadlin
                        //   T=2: bootsect-loader
                        //   T=3: SYSLINUX
                        //   T=4: ETHERBOOT
                        //   V=version
  /* 0x211 */ uint8_t   loadflags;
                        // bit0 = 1: kernel is loaded high (bzImage)
                        // bit7 = 1: Heap and pointer (see below) set by boot
                        //   loader.
  /* 0x212 */ uint16_t  setup_S_temp1;
  /* 0x214 */ uint32_t  kernel_start;
  /* 0x218 */ uint32_t  initrd_start;
  /* 0x21c */ uint32_t  initrd_size;
  /* 0x220 */ uint8_t   setup_S_temp2[4];
  /* 0x224 */ uint16_t  setup_S_heap_end_pointer;
  /* 0x226 */ uint16_t  pad70;
  /* 0x228 */ uint32_t  cmd_line_ptr;
  /* 0x22c */ uint8_t   pad7[0x2d0 - 0x22c];

  /* 0x2d0 : Int 15, ax=e820 memory map. */
  // (linux/include/asm-i386/e820.h, 'struct e820entry')
#define E820MAX  32
#define E820_RAM  1
#define E820_RESERVED 2
#define E820_ACPI 3 /* usable as RAM once ACPI tables have been read */
#define E820_NVS  4
  struct {
    uint64_t addr;
    uint64_t size;
    uint32_t type;
    } e820map[E820MAX];

  /* 0x550 */ uint8_t   pad8[0x600 - 0x550];

  // BIOS Enhanced Disk Drive Services.
  // (From linux/include/asm-i386/edd.h, 'struct edd_info')
  // Each 'struct edd_info is 78 bytes, times a max of 6 structs in array.
  /* 0x600 */ uint8_t   eddbuf[0x7d4 - 0x600];

  /* 0x7d4 */ uint8_t   pad9[0x800 - 0x7d4];
  /* 0x800 */ uint8_t   commandline[0x800];

  /* 0x1000 */
  uint64_t gdt_table[256];
  uint64_t idt_table[48];
};

void setup(int phys_ram_size, int initrd_size, char *cmdline)
{
    struct linux_params *params;
    struct __attribute__((packed)) {
        uint16_t limit;
        void *addr;
    } gdt_data;

    put_string("Starting Linux\n");

    params = (struct linux_params *)KERNEL_PARAMS_ADDR;

    memset(params, 0, sizeof(struct linux_params));
    params->mount_root_rdonly = 0;
    params->cmd_line_ptr = (uintptr_t)params->commandline;
    params->alt_mem_k = (phys_ram_size / 1024) - 1024;
    
    strcpy((char *)params->commandline, cmdline);

    params->loader_type = 0x01;

    if (initrd_size > 0) {
        params->initrd_start = INITRD_LOAD_ADDR;
        params->initrd_size = initrd_size;
    }

    params->orig_video_lines = 25;
    params->orig_video_cols = 80;

    params->gdt_table[2] = 0x00cf9a000000ffffLL; /* KERNEL_CS */
    params->gdt_table[3] = 0x00cf92000000ffffLL; /* KERNEL_DS */

    gdt_data.limit = sizeof(params->gdt_table);
    gdt_data.addr = params->gdt_table;
    
    /* init gdt */
    asm volatile ("lgdt (%0)" : : "r" (&gdt_data) : "memory");
}