Compare commits
No commits in common. 'master' and 'master' have entirely different histories.
Binary file not shown.
@ -1,125 +0,0 @@
|
||||
#
|
||||
# if you want the ram-disk device, define this to be the
|
||||
# size in blocks.
|
||||
#
|
||||
RAMDISK = #-DRAMDISK=512
|
||||
|
||||
AS86 =as86 -0 -a
|
||||
LD86 =ld86 -0
|
||||
|
||||
AS =as
|
||||
LD =ld
|
||||
LDFLAGS =-m elf_i386 -Ttext 0 -e startup_32 -Map=System.map.2 -N
|
||||
CC =gcc -march=i386 $(RAMDISK)
|
||||
CFLAGS =-w -g -fstrength-reduce -fomit-frame-pointer -fno-stack-protector -mcld
|
||||
CPP =cpp -nostdinc -Iinclude
|
||||
|
||||
#
|
||||
# ROOT_DEV specifies the default root-device when making the image.
|
||||
# This can be either FLOPPY, /dev/xxxx or empty, in which case the
|
||||
# default of /dev/hd6 is used by 'build'.
|
||||
#
|
||||
ROOT_DEV=
|
||||
|
||||
ARCHIVES=kernel/kernel.o mm/mm.o fs/fs.o
|
||||
DRIVERS =kernel/blk_drv/blk_drv.a kernel/chr_drv/chr_drv.a
|
||||
MATH =kernel/math/math.a
|
||||
LIBS =lib/lib.a
|
||||
|
||||
.c.s:
|
||||
$(CC) $(CFLAGS) \
|
||||
-nostdinc -Iinclude -S -o $*.s $<
|
||||
.s.o:
|
||||
$(AS) -o $*.o $<
|
||||
.c.o:
|
||||
$(CC) $(CFLAGS) \
|
||||
-nostdinc -Iinclude -c -o $*.o $<
|
||||
|
||||
all: Image
|
||||
|
||||
Image: boot/bootsect boot/setup tools/system tools/build
|
||||
cp -f tools/system system.tmp
|
||||
strip system.tmp
|
||||
tools/build boot/bootsect boot/setup system.tmp $(ROOT_DEV) > Image
|
||||
rm -f system.tmp
|
||||
sync
|
||||
|
||||
disk: Image
|
||||
dd bs=8192 if=Image of=/dev/PS0
|
||||
|
||||
tools/build: tools/build.c
|
||||
$(CC) $(CFLAGS) \
|
||||
-o tools/build tools/build.c
|
||||
|
||||
boot/head.o: boot/head.s
|
||||
|
||||
tools/system: boot/head.o init/main.o \
|
||||
$(ARCHIVES) $(DRIVERS) $(MATH) $(LIBS)
|
||||
$(LD) $(LDFLAGS) boot/head.o init/main.o \
|
||||
$(ARCHIVES) \
|
||||
$(DRIVERS) \
|
||||
$(MATH) \
|
||||
$(LIBS) \
|
||||
-o tools/system
|
||||
nm tools/system | grep -v '\(compiled\)\|\(\.o$$\)\|\( [aUw]\)\|\(\.\.ng$$\)\|\(LASH[RL]DI\)' | sort >System.map
|
||||
|
||||
kernel/math/math.a: FORCE
|
||||
(cd kernel/math; make)
|
||||
|
||||
kernel/blk_drv/blk_drv.a: FORCE
|
||||
(cd kernel/blk_drv; make)
|
||||
|
||||
kernel/chr_drv/chr_drv.a: FORCE
|
||||
(cd kernel/chr_drv; make)
|
||||
|
||||
kernel/kernel.o: FORCE
|
||||
(cd kernel; make)
|
||||
|
||||
mm/mm.o: FORCE
|
||||
(cd mm; make)
|
||||
|
||||
fs/fs.o: FORCE
|
||||
(cd fs; make)
|
||||
|
||||
lib/lib.a: FORCE
|
||||
(cd lib; make)
|
||||
|
||||
FORCE:
|
||||
|
||||
boot/setup: boot/setup.s
|
||||
$(AS86) -o boot/setup.o boot/setup.s
|
||||
$(LD86) -s -o boot/setup boot/setup.o
|
||||
|
||||
boot/bootsect: boot/bootsect.s
|
||||
$(AS86) -o boot/bootsect.o boot/bootsect.s
|
||||
$(LD86) -s -o boot/bootsect boot/bootsect.o
|
||||
|
||||
tmp.s: boot/bootsect.s tools/system
|
||||
(echo -n "SYSSIZE = (";ls -l tools/system | grep system \
|
||||
| cut -c25-31 | tr '\012' ' '; echo "+ 15 ) / 16") > tmp.s
|
||||
cat boot/bootsect.s >> tmp.s
|
||||
|
||||
clean:
|
||||
rm -f Image System.map tmp_make core System.map.2
|
||||
rm -f boot/bootsect boot/setup
|
||||
rm -f init/*.o tools/system tools/build boot/*.o
|
||||
(cd mm;make clean)
|
||||
(cd fs;make clean)
|
||||
(cd kernel;make clean)
|
||||
(cd lib;make clean)
|
||||
|
||||
dep:
|
||||
sed '/\#\#\# Dependencies/q' < Makefile > tmp_make
|
||||
(for i in init/*.c;do echo -n "init/";$(CPP) -M $$i;done) >> tmp_make
|
||||
cp tmp_make Makefile
|
||||
(cd fs; make dep)
|
||||
(cd kernel; make dep)
|
||||
(cd mm; make dep)
|
||||
|
||||
### Dependencies:
|
||||
init/main.o : init/main.c include/unistd.h include/sys/stat.h \
|
||||
include/sys/types.h include/sys/times.h include/sys/utsname.h \
|
||||
include/utime.h include/time.h include/linux/tty.h include/termios.h \
|
||||
include/linux/sched.h include/linux/head.h include/linux/fs.h \
|
||||
include/linux/mm.h include/signal.h include/asm/system.h include/asm/io.h \
|
||||
include/stddef.h include/stdarg.h include/fcntl.h
|
||||
@ -1,587 +0,0 @@
|
||||
00000000 T pg_dir
|
||||
00000000 T startup_32
|
||||
0000005a t check_x87
|
||||
00000073 t setup_idt
|
||||
00000090 t rp_sidt
|
||||
000000a3 t setup_gdt
|
||||
00001000 t pg0
|
||||
00002000 t pg1
|
||||
00003000 t pg2
|
||||
00004000 t pg3
|
||||
00005000 T tmp_floppy_area
|
||||
00005412 t L6
|
||||
00005414 t int_msg
|
||||
00005428 t ignore_int
|
||||
00005450 t setup_paging
|
||||
000054ae t idt_descr
|
||||
000054b6 t gdt_descr
|
||||
000054c0 T idt
|
||||
00005cc0 T gdt
|
||||
000064c0 T fork
|
||||
000064ef T pause
|
||||
0000651e T setup
|
||||
00006555 T sync
|
||||
00006584 t time_init
|
||||
00006799 T main
|
||||
0000690c t printf
|
||||
0000695b T init
|
||||
00006bd4 T show_task
|
||||
00006c59 T show_stat
|
||||
00006c9f T math_state_restore
|
||||
00006cfd T schedule
|
||||
00006eaf T sys_pause
|
||||
00006ec5 T sleep_on
|
||||
00006f24 T interruptible_sleep_on
|
||||
00006fdf T ticks_to_floppy_on
|
||||
000070aa T floppy_on
|
||||
000070d9 T floppy_off
|
||||
000070e9 T do_floppy_timer
|
||||
000072e1 T do_timer
|
||||
000073d0 T sys_alarm
|
||||
0000744f T sys_getpid
|
||||
0000745b T sys_getppid
|
||||
00007467 T sys_getuid
|
||||
00007476 T sys_geteuid
|
||||
00007486 T sys_getgid
|
||||
00007496 T sys_getegid
|
||||
000074a5 T sys_nice
|
||||
000074d0 T sched_init
|
||||
00007660 t bad_sys_call
|
||||
00007668 t reschedule
|
||||
00007674 T system_call
|
||||
000076a8 t ret_from_sys_call
|
||||
000076f0 T coprocessor_error
|
||||
00007712 T device_not_available
|
||||
0000774c T timer_interrupt
|
||||
00007784 T sys_execve
|
||||
00007794 T sys_execve2
|
||||
000077a4 T sys_fork
|
||||
000077bc T hd_interrupt
|
||||
000077f8 T floppy_interrupt
|
||||
0000782e T parallel_interrupt
|
||||
00007835 t _get_base
|
||||
00007867 t die
|
||||
00007a49 T do_double_fault
|
||||
00007a6c T do_general_protection
|
||||
00007a8f T do_divide_error
|
||||
00007ab2 T do_int3
|
||||
00007b7a T do_nmi
|
||||
00007b9d T do_debug
|
||||
00007bc0 T do_overflow
|
||||
00007be3 T do_bounds
|
||||
00007c06 T do_invalid_op
|
||||
00007c29 T do_device_not_available
|
||||
00007c4c T do_coprocessor_segment_overrun
|
||||
00007c6f T do_invalid_TSS
|
||||
00007c92 T do_segment_not_present
|
||||
00007cb5 T do_stack_segment
|
||||
00007cd8 T do_coprocessor_error
|
||||
00007d0c T do_reserved
|
||||
00007d2f T trap_init
|
||||
00008013 T divide_error
|
||||
00008018 t no_error_code
|
||||
00008048 T debug
|
||||
0000804f T nmi
|
||||
00008056 T int3
|
||||
0000805d T overflow
|
||||
00008064 T bounds
|
||||
0000806b T invalid_op
|
||||
00008072 T coprocessor_segment_overrun
|
||||
00008079 T reserved
|
||||
00008080 T irq13
|
||||
00008095 T double_fault
|
||||
0000809a t error_code
|
||||
000080cc T invalid_TSS
|
||||
000080d3 T segment_not_present
|
||||
000080da T stack_segment
|
||||
000080e1 T general_protection
|
||||
000080e8 t _get_base
|
||||
0000811a T verify_area
|
||||
00008181 T copy_mem
|
||||
000082db T copy_process
|
||||
00008788 T find_empty_process
|
||||
0000881c T panic
|
||||
00008857 T printk
|
||||
000088a8 t skip_atoi
|
||||
00008903 t number
|
||||
00008b74 T vsprintf
|
||||
00009000 t get_fs_long
|
||||
00009016 t put_fs_byte
|
||||
0000902e t put_fs_long
|
||||
0000903a T sys_ftime
|
||||
00009040 T sys_break
|
||||
00009046 T sys_ptrace
|
||||
0000904c T sys_stty
|
||||
00009052 T sys_gtty
|
||||
00009058 T sys_rename
|
||||
0000905e T sys_prof
|
||||
00009064 T sys_setregid
|
||||
0000911d T sys_setgid
|
||||
000091b4 T sys_acct
|
||||
000091ba T sys_phys
|
||||
000091c0 T sys_lock
|
||||
000091c6 T sys_mpx
|
||||
000091cc T sys_ulimit
|
||||
000091d2 T sys_time
|
||||
0000922e T sys_setreuid
|
||||
00009310 T sys_setuid
|
||||
000093a5 T sys_stime
|
||||
000093fb T sys_times
|
||||
0000949b T sys_brk
|
||||
000094dd T sys_setpgid
|
||||
000095b6 T sys_getpgrp
|
||||
000095c2 T sys_setsid
|
||||
0000963c T sys_getgroups
|
||||
00009642 T sys_setgroups
|
||||
00009648 T sys_uname
|
||||
000096b1 T sys_sethostname
|
||||
000096b7 T sys_getrlimit
|
||||
000096bd T sys_setrlimit
|
||||
000096c3 T sys_getrusage
|
||||
000096c9 T sys_gettimeofday
|
||||
000096cf T sys_settimeofday
|
||||
000096d5 T sys_umask
|
||||
00009708 T sys_sleep
|
||||
0000976d T sys_getdents
|
||||
000098e5 T sys_getcwd
|
||||
00009ad6 T sys_getpipe2
|
||||
00009adc t _get_base
|
||||
00009b0e t put_fs_long
|
||||
00009b1a T release
|
||||
00009b7e t send_sig
|
||||
00009bfd t kill_session
|
||||
00009c57 T sys_kill
|
||||
00009e07 t tell_father
|
||||
00009e91 T do_exit
|
||||
0000a0c5 T sys_exit
|
||||
0000a0de T sys_waitpid
|
||||
0000a304 t get_fs_byte
|
||||
0000a312 t put_fs_byte
|
||||
0000a32a t put_fs_long
|
||||
0000a336 T sys_sgetmask
|
||||
0000a342 T sys_ssetmask
|
||||
0000a36e T sys_sigpending
|
||||
0000a374 T sys_sigsuspend
|
||||
0000a37a t save_old
|
||||
0000a3cd t get_new
|
||||
0000a40d T sys_signal
|
||||
0000a491 T sys_sigaction
|
||||
0000a59b T do_signal
|
||||
0000a787 T kernel_mktime
|
||||
0000a8cc t oom
|
||||
0000a8eb T get_free_page
|
||||
0000a927 T free_page
|
||||
0000a996 T free_page_tables
|
||||
0000aa95 T copy_page_tables
|
||||
0000ac16 T put_page
|
||||
0000ad02 T un_wp_page
|
||||
0000adba T do_wp_page
|
||||
0000ae45 T get_empty_page
|
||||
0000ae85 t try_to_share
|
||||
0000b017 t share_page
|
||||
0000b0cb T do_no_page
|
||||
0000b22d T mem_init
|
||||
0000b2a1 T calc_mem
|
||||
0000b396 T page_fault
|
||||
0000b3cd t get_fs_long
|
||||
0000b3e3 T sys_ustat
|
||||
0000b3e9 T sys_utime
|
||||
0000b496 T sys_access
|
||||
0000b572 T sys_chdir
|
||||
0000b5e6 T sys_chroot
|
||||
0000b65a T sys_chmod
|
||||
0000b6f4 T sys_chown
|
||||
0000b76f T sys_open
|
||||
0000ba12 T sys_creat
|
||||
0000ba35 T sys_close
|
||||
0000bb04 T sys_lseek
|
||||
0000bc1b T sys_read
|
||||
0000be0e T sys_write
|
||||
0000bfbc t lock_inode
|
||||
0000bfe9 t unlock_inode
|
||||
0000c007 T invalidate_inodes
|
||||
0000c076 T sync_inodes
|
||||
0000c0cd t _bmap
|
||||
0000c4b9 T bmap
|
||||
0000c4dc T create_block
|
||||
0000c4ff T iput
|
||||
0000c66e T get_empty_inode
|
||||
0000c7c3 T get_pipe_inode
|
||||
0000c838 T iget
|
||||
0000c9fd t read_inode
|
||||
0000cc33 T sys_sync
|
||||
0000cc96 T sync_dev
|
||||
0000cd8f T invalidate_buffers
|
||||
0000ce01 T check_disk_change
|
||||
0000ceab t remove_from_queues
|
||||
0000cfa2 t insert_into_queues
|
||||
0000d067 t find_buffer
|
||||
0000d0cf T get_hash_table
|
||||
0000d151 T getblk
|
||||
0000d2ef T brelse
|
||||
0000d338 T bread
|
||||
0000d3bd T bread_page
|
||||
0000d4df T breada
|
||||
0000d5d4 T buffer_init
|
||||
0000d703 t lock_super
|
||||
0000d730 t free_super
|
||||
0000d775 T get_super
|
||||
0000d7e4 T put_super
|
||||
0000d8b7 t read_super
|
||||
0000dbfa T sys_umount
|
||||
0000dd5b T sys_mount
|
||||
0000decc T mount_root
|
||||
0000e0da t get_fs_byte
|
||||
0000e0e8 t put_fs_byte
|
||||
0000e100 T block_write
|
||||
0000e252 T block_read
|
||||
0000e37d t get_fs_byte
|
||||
0000e38b t put_fs_byte
|
||||
0000e3a3 t rw_ttyx
|
||||
0000e3eb t rw_tty
|
||||
0000e43b t rw_ram
|
||||
0000e441 t rw_mem
|
||||
0000e447 t rw_kmem
|
||||
0000e44d t rw_port
|
||||
0000e4e7 t rw_memory
|
||||
0000e5bd T rw_char
|
||||
0000e627 t get_fs_byte
|
||||
0000e635 t put_fs_byte
|
||||
0000e64d T file_read
|
||||
0000e7f8 T file_write
|
||||
0000e9f2 t put_fs_byte
|
||||
0000ea0a t cp_stat
|
||||
0000eae1 T sys_stat
|
||||
0000eb2b T sys_lstat
|
||||
0000eb46 T sys_fstat
|
||||
0000eba3 T sys_readlink
|
||||
0000eba9 t _get_base
|
||||
0000ebdb t get_fs_byte
|
||||
0000ebe9 t get_fs_long
|
||||
0000ebff t put_fs_byte
|
||||
0000ec17 t put_fs_long
|
||||
0000ec23 t get_fs
|
||||
0000ec37 t get_ds
|
||||
0000ec4b t set_fs
|
||||
0000ec52 T sys_uselib
|
||||
0000ec58 t create_tables
|
||||
0000eda3 t count
|
||||
0000ede2 t copy_strings
|
||||
0000ef9e t change_ldt
|
||||
0000f121 T do_execve
|
||||
0000fba3 T do_execve2
|
||||
00010681 t get_fs_byte
|
||||
0001068f t put_fs_byte
|
||||
000106a7 t put_fs_long
|
||||
000106b3 T read_pipe
|
||||
00010988 T sys_pipe
|
||||
00010b8a t get_fs_byte
|
||||
00010b98 t permission
|
||||
00010c39 t match
|
||||
00010ca1 t find_entry
|
||||
000110fb t get_dir
|
||||
000112e8 t dir_namei
|
||||
00011367 T namei
|
||||
0001147d T open_namei
|
||||
000117d0 T sys_mknod
|
||||
00011a00 T sys_mkdir
|
||||
00011db1 t empty_dir
|
||||
00011f8f T sys_rmdir
|
||||
000122e7 T sys_unlink
|
||||
00012588 T sys_symlink
|
||||
0001258e T sys_link
|
||||
000127e8 T free_block
|
||||
0001295a T new_block
|
||||
00012afe T free_inode
|
||||
00012c65 T new_inode
|
||||
00012e3f t dupfd
|
||||
00012f19 T sys_dup2
|
||||
00012f40 T sys_dup
|
||||
00012f5b T sys_fcntl
|
||||
0001309a T sys_ioctl
|
||||
0001316b t free_ind
|
||||
0001320a t free_dind
|
||||
000132a9 T truncate
|
||||
000133de T sys_select
|
||||
000133e4 t lock_buffer
|
||||
00013411 t unlock_buffer
|
||||
00013603 t make_request
|
||||
000137a7 T ll_rw_block
|
||||
00013800 T blk_dev_init
|
||||
0001384e t unlock_buffer
|
||||
00013883 t end_request
|
||||
00013934 T floppy_deselect
|
||||
0001396b T floppy_change
|
||||
000139f1 t setup_DMA
|
||||
00013aa7 t output_byte
|
||||
00013b1d t result
|
||||
00013bda t bad_flp_intr
|
||||
00013c39 t rw_interrupt
|
||||
00013d28 T setup_rw_floppy
|
||||
00013de9 t seek_interrupt
|
||||
00013e42 t transfer
|
||||
00013f77 t recal_interrupt
|
||||
00013fc1 T unexpected_floppy_interrupt
|
||||
00014006 t recalibrate_floppy
|
||||
00014068 t reset_interrupt
|
||||
000140ad t reset_floppy
|
||||
0001412a t floppy_on_interrupt
|
||||
00014195 t do_fd_request
|
||||
00014399 T floppy_init
|
||||
000143eb t unlock_buffer
|
||||
00014420 t end_request
|
||||
000144bf T sys_setup
|
||||
00014872 t controller_ready
|
||||
00014906 t hd_out
|
||||
000149f3 t drive_busy
|
||||
00014a59 t reset_controller
|
||||
00014ad6 t reset_hd
|
||||
00014b6e T unexpected_hd_interrupt
|
||||
00014b81 t bad_rw_intr
|
||||
00014bbf t read_intr
|
||||
00014ce5 t recal_intr
|
||||
00014cff t do_hd_request
|
||||
00015000 T hd_init
|
||||
0001507a t unlock_buffer
|
||||
000150af t end_request
|
||||
0001514e t do_rd_request
|
||||
00015284 T rd_init
|
||||
000152da T rd_load
|
||||
00015586 t get_fs_byte
|
||||
00015594 t put_fs_byte
|
||||
000155ac T tty_init
|
||||
000155bd T tty_intr
|
||||
00015631 t sleep_if_empty
|
||||
00015669 t sleep_if_full
|
||||
000156dd T copy_to_cooked
|
||||
00015c98 T tty_read
|
||||
00016006 T tty_write
|
||||
00016218 T do_tty_interrupt
|
||||
00016240 T chr_dev_init
|
||||
00016241 t gotoxy
|
||||
0001628f t set_origin
|
||||
000162f5 t scrup
|
||||
000164e5 t scrdown
|
||||
000165dc t lf
|
||||
00016612 t ri
|
||||
00016648 t cr
|
||||
00016669 t del
|
||||
0001669b t csi_J
|
||||
0001672c t csi_K
|
||||
000167de T csi_m
|
||||
00016845 t set_cursor
|
||||
000168ab t respond
|
||||
00016903 t insert_char
|
||||
00016966 t insert_line
|
||||
000169aa t delete_char
|
||||
00016a08 t delete_line
|
||||
00016a4c t csi_at
|
||||
00016a8a t csi_L
|
||||
00016ac8 t csi_P
|
||||
00016b06 t csi_M
|
||||
00016b44 t save_cur
|
||||
00016b59 t restore_cur
|
||||
00016b78 T con_write
|
||||
00017206 T con_init
|
||||
0001743d T sysbeepstop
|
||||
00017466 t sysbeep
|
||||
000174c4 t mode
|
||||
000174c5 t leds
|
||||
000174c6 t e0
|
||||
000174c7 T keyboard_interrupt
|
||||
000174f0 t e0_e1
|
||||
0001751b t set_e0
|
||||
00017524 t set_e1
|
||||
0001752d t put_queue
|
||||
00017566 t ctrl
|
||||
0001757e t unctrl
|
||||
00017582 t unalt
|
||||
00017598 t lshift
|
||||
000175a0 t unlshift
|
||||
000175a8 t rshift
|
||||
000175b0 t unrshift
|
||||
000175b8 t caps
|
||||
000175da t set_leds
|
||||
000175f0 t uncaps
|
||||
000175f8 t scroll
|
||||
00017601 t num
|
||||
0001760a t cursor
|
||||
0001762a t cur2
|
||||
00017653 t cur
|
||||
0001765f t ok_cur
|
||||
0001766d t num_table
|
||||
0001767a t cur_table
|
||||
00017687 t func
|
||||
000176a4 t ok_func
|
||||
000176b7 t end_func
|
||||
000176b8 t func_table
|
||||
000176e8 t key_map
|
||||
00017749 t shift_map
|
||||
0001780b t do_self
|
||||
00017873 t none
|
||||
00017874 t minus
|
||||
00017889 t key_table
|
||||
00017c89 t kb_wait
|
||||
00017c92 t reboot
|
||||
00017ca4 t die
|
||||
00017ca6 t init
|
||||
00017d1b T rs_init
|
||||
00017d9e T rs_write
|
||||
00017dec T rs1_interrupt
|
||||
00017df4 T rs2_interrupt
|
||||
00017df9 t rs_int
|
||||
00017e10 t rep_int
|
||||
00017e2d t end
|
||||
00017e3b t jmp_table
|
||||
00017e4c t modem_status
|
||||
00017e54 t line_status
|
||||
00017e5c t read_char
|
||||
00017ee3 t get_fs_byte
|
||||
00017ef1 t get_fs_long
|
||||
00017f07 t put_fs_byte
|
||||
00017f1f t put_fs_long
|
||||
00017f2b t change_speed
|
||||
00017fa9 t flush
|
||||
00017fbb t send_break
|
||||
00017fbc t get_termios
|
||||
00018018 t set_termios
|
||||
00018068 t get_termio
|
||||
00018130 t set_termio
|
||||
000181f4 T tty_ioctl
|
||||
000184f2 t get_fs_byte
|
||||
00018500 T math_emulate
|
||||
000185e3 T math_error
|
||||
00018603 T _exit
|
||||
00018613 T open
|
||||
0001865c T close
|
||||
000186d0 T dup
|
||||
00018707 T setsid
|
||||
00018736 T execve
|
||||
000187d3 T strcpy
|
||||
000187ef T strncpy
|
||||
00018814 T strcat
|
||||
0001883f T strncat
|
||||
00018874 T strcmp
|
||||
0001889b T strncmp
|
||||
000188c9 T strchr
|
||||
000188f6 T strrchr
|
||||
00018925 T strspn
|
||||
00018962 T strcspn
|
||||
0001899f T strpbrk
|
||||
000189d6 T strstr
|
||||
00018a0f T strlen
|
||||
00018a32 T strtok
|
||||
00018ab5 T memcpy
|
||||
00018ad5 T memmove
|
||||
00018b29 T memcmp
|
||||
00018b53 T memchr
|
||||
00018b8b T memset
|
||||
00018baf t init_bucket_desc
|
||||
00018c18 T malloc
|
||||
00018da4 T free_s
|
||||
0001cf28 d envp_rc
|
||||
0001cf3c d envp
|
||||
0001cf60 D sys_call_table
|
||||
0001d0d0 D NR_syscalls
|
||||
0001d0e0 d init_task
|
||||
0001e0e0 D current
|
||||
0001e100 D task
|
||||
0001e200 D stack_start
|
||||
0001e208 D current_DOR
|
||||
0001e220 d thisname.1960
|
||||
0001e260 d month
|
||||
0001e2a0 d last_inode.1940
|
||||
0001e2a4 D start_buffer
|
||||
0001e2c0 d crw_table
|
||||
0001e2e0 d ioctl_table
|
||||
0001e300 d floppy_type
|
||||
0001e3c0 d cur_spec1
|
||||
0001e3c4 d cur_rate
|
||||
0001e3c8 d floppy
|
||||
0001e3cc d current_track
|
||||
0001e3d0 d callable.1849
|
||||
0001e3e0 D tty_table
|
||||
00020900 D table_list
|
||||
00020920 d quotient
|
||||
00020940 D _ctype
|
||||
00020a60 D bucket_dir
|
||||
00020ab0 B __bss_start
|
||||
00020ab0 D _edata
|
||||
00020ac0 b printbuf
|
||||
00020ec0 b memory_end
|
||||
00020ec4 b buffer_memory_end
|
||||
00020ec8 b main_memory_start
|
||||
00020ee0 B jiffies
|
||||
00020ee4 B startup_time
|
||||
00020ee8 B last_task_used_math
|
||||
00020efc b mon_timer
|
||||
00020f0c b moff_timer
|
||||
00020f20 b timer_list
|
||||
00021220 b next_timer
|
||||
00021224 B last_pid
|
||||
00021240 b buf
|
||||
00021640 b HIGH_MEMORY
|
||||
00021660 b mem_map
|
||||
00022560 B inode_table
|
||||
00022c60 B nr_buffers
|
||||
00022c64 b free_list
|
||||
00022c68 b buffer_wait
|
||||
00022c6c B ROOT_DEV
|
||||
00022ca0 B blk_dev
|
||||
00022cd8 B do_floppy
|
||||
00022cdc B selected
|
||||
00022ce4 b recalibrate
|
||||
00022ce8 b reset
|
||||
00022cec b seek
|
||||
00022cf0 b reply_buffer
|
||||
00022cf7 b current_drive
|
||||
00022cf8 b sector
|
||||
00022cf9 b head
|
||||
00022cfa b track
|
||||
00022cfb b seek_track
|
||||
00022cfc b command
|
||||
00022d00 B do_hd
|
||||
00022d20 B hd_info
|
||||
00022d50 b recalibrate
|
||||
00022d54 b reset
|
||||
00022d58 b NR_HD
|
||||
00022d60 b hd
|
||||
00022db0 B rd_length
|
||||
00022db4 b cr_flag.1928
|
||||
00022dc0 B beepcount
|
||||
00022dc4 b video_type
|
||||
00022dc8 b video_num_columns
|
||||
00022dcc b video_size_row
|
||||
00022dd0 b video_num_lines
|
||||
00022dd4 b video_page
|
||||
00022dd8 b video_mem_start
|
||||
00022ddc b video_mem_end
|
||||
00022de0 b video_port_reg
|
||||
00022de2 b video_port_val
|
||||
00022de4 b video_erase_char
|
||||
00022de8 b origin
|
||||
00022dec b scr_end
|
||||
00022df0 b pos
|
||||
00022df4 b x
|
||||
00022df8 b y
|
||||
00022dfc b top
|
||||
00022e00 b bottom
|
||||
00022e04 b state
|
||||
00022e08 b npar
|
||||
00022e20 b par
|
||||
00022e60 b ques
|
||||
00022e64 b saved_x
|
||||
00022e68 b saved_y
|
||||
00022e6c B free_bucket_desc
|
||||
00022e80 B drive_info
|
||||
00022ea0 B user_stack
|
||||
00023ea0 B hash_table
|
||||
00024380 B super_block
|
||||
000246e0 B file_table
|
||||
00024ae0 B request
|
||||
00024f60 B rd_start
|
||||
00024f64 B _ctmp
|
||||
00024f68 B errno
|
||||
00024f6c B ___strtok
|
||||
00024f70 B end
|
||||
00024f70 B _end
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,41 +0,0 @@
|
||||
diff -Naur 0/linux/init/main.c 4/linux/init/main.c
|
||||
--- 0/linux/init/main.c 2016-08-08 09:40:13.000000000 +0800
|
||||
+++ 4/linux/init/main.c 2021-07-06 14:16:56.000000000 +0800
|
||||
@@ -208,3 +208,9 @@
|
||||
}
|
||||
_exit(0); /* NOTE! _exit, not exit() */
|
||||
}
|
||||
+
|
||||
+void print_nr(int sid)
|
||||
+{
|
||||
+ if (sid > 86)
|
||||
+ printk(" --syscall: sid=%d, pid=%d\n", sid, current->pid);
|
||||
+}
|
||||
diff -Naur 0/linux/kernel/system_call.s 4/linux/kernel/system_call.s
|
||||
--- 0/linux/kernel/system_call.s 2015-09-03 20:21:09.000000000 +0800
|
||||
+++ 4/linux/kernel/system_call.s 2021-07-06 14:18:56.000000000 +0800
|
||||
@@ -91,6 +91,11 @@
|
||||
mov %dx,%es
|
||||
movl $0x17,%edx # fs points to local data space
|
||||
mov %dx,%fs
|
||||
+
|
||||
+ pushl %eax #by wyj
|
||||
+ call print_nr
|
||||
+ popl %eax
|
||||
+
|
||||
call sys_call_table(,%eax,4)
|
||||
pushl %eax
|
||||
movl current,%eax
|
||||
diff -Naur 0/linux/mm/memory.c 4/linux/mm/memory.c
|
||||
--- 0/linux/mm/memory.c 2015-09-04 15:24:20.000000000 +0800
|
||||
+++ 4/linux/mm/memory.c 2021-07-06 14:21:45.000000000 +0800
|
||||
@@ -370,6 +370,9 @@
|
||||
unsigned long page;
|
||||
int block,i;
|
||||
|
||||
+ if (current->pid > 5)
|
||||
+ printk(" --do_no_page: address=%x, pid=%d\n", address, current->pid);
|
||||
+
|
||||
address &= 0xfffff000;
|
||||
tmp = address - current->start_code;
|
||||
if (!current->executable || tmp >= current->end_data) {
|
||||
@ -1,101 +0,0 @@
|
||||
AR =ar
|
||||
AS =as
|
||||
LD =ld
|
||||
LDFLAGS =-s -x
|
||||
CC =gcc -march=i386
|
||||
CFLAGS =-w -g -fstrength-reduce -fomit-frame-pointer -mcld \
|
||||
-finline-functions -nostdinc -fno-stack-protector -I../include
|
||||
CPP =gcc -E -nostdinc -I../include
|
||||
|
||||
.c.s:
|
||||
$(CC) $(CFLAGS) \
|
||||
-S -o $*.s $<
|
||||
.c.o:
|
||||
$(CC) $(CFLAGS) \
|
||||
-c -o $*.o $<
|
||||
.s.o:
|
||||
$(AS) -o $*.o $<
|
||||
|
||||
OBJS= open.o read_write.o inode.o file_table.o buffer.o super.o \
|
||||
block_dev.o char_dev.o file_dev.o stat.o exec.o pipe.o namei.o \
|
||||
bitmap.o fcntl.o ioctl.o truncate.o select.o
|
||||
|
||||
fs.o: $(OBJS)
|
||||
$(LD) -r -o fs.o $(OBJS)
|
||||
|
||||
clean:
|
||||
rm -f core *.o *.a tmp_make
|
||||
for i in *.c;do rm -f `basename $$i .c`.s;done
|
||||
|
||||
dep:
|
||||
sed '/\#\#\# Dependencies/q' < Makefile > tmp_make
|
||||
(for i in *.c;do $(CPP) -M $$i;done) >> tmp_make
|
||||
cp tmp_make Makefile
|
||||
|
||||
### Dependencies:
|
||||
bitmap.o : bitmap.c ../include/string.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h
|
||||
block_dev.o : block_dev.c ../include/errno.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h \
|
||||
../include/asm/segment.h ../include/asm/system.h
|
||||
buffer.o : buffer.c ../include/stdarg.h ../include/linux/config.h \
|
||||
../include/linux/sched.h ../include/linux/head.h ../include/linux/fs.h \
|
||||
../include/sys/types.h ../include/linux/mm.h ../include/signal.h \
|
||||
../include/linux/kernel.h ../include/asm/system.h ../include/asm/io.h
|
||||
char_dev.o : char_dev.c ../include/errno.h ../include/sys/types.h \
|
||||
../include/linux/sched.h ../include/linux/head.h ../include/linux/fs.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h \
|
||||
../include/asm/segment.h ../include/asm/io.h
|
||||
exec.o : exec.c ../include/errno.h ../include/string.h \
|
||||
../include/sys/stat.h ../include/sys/types.h ../include/a.out.h \
|
||||
../include/linux/fs.h ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h \
|
||||
../include/asm/segment.h
|
||||
fcntl.o : fcntl.c ../include/string.h ../include/errno.h \
|
||||
../include/linux/sched.h ../include/linux/head.h ../include/linux/fs.h \
|
||||
../include/sys/types.h ../include/linux/mm.h ../include/signal.h \
|
||||
../include/linux/kernel.h ../include/asm/segment.h ../include/fcntl.h \
|
||||
../include/sys/stat.h
|
||||
file_dev.o : file_dev.c ../include/errno.h ../include/fcntl.h \
|
||||
../include/sys/types.h ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/fs.h ../include/linux/mm.h ../include/signal.h \
|
||||
../include/linux/kernel.h ../include/asm/segment.h
|
||||
file_table.o : file_table.c ../include/linux/fs.h ../include/sys/types.h
|
||||
inode.o : inode.c ../include/string.h ../include/sys/stat.h \
|
||||
../include/sys/types.h ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/fs.h ../include/linux/mm.h ../include/signal.h \
|
||||
../include/linux/kernel.h ../include/asm/system.h
|
||||
ioctl.o : ioctl.c ../include/string.h ../include/errno.h \
|
||||
../include/sys/stat.h ../include/sys/types.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/linux/mm.h \
|
||||
../include/signal.h
|
||||
namei.o : namei.c ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/fs.h ../include/sys/types.h ../include/linux/mm.h \
|
||||
../include/signal.h ../include/linux/kernel.h ../include/asm/segment.h \
|
||||
../include/string.h ../include/fcntl.h ../include/errno.h \
|
||||
../include/const.h ../include/sys/stat.h
|
||||
open.o : open.c ../include/string.h ../include/errno.h ../include/fcntl.h \
|
||||
../include/sys/types.h ../include/utime.h ../include/sys/stat.h \
|
||||
../include/linux/sched.h ../include/linux/head.h ../include/linux/fs.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/tty.h \
|
||||
../include/termios.h ../include/linux/kernel.h ../include/asm/segment.h
|
||||
pipe.o : pipe.c ../include/signal.h ../include/sys/types.h \
|
||||
../include/linux/sched.h ../include/linux/head.h ../include/linux/fs.h \
|
||||
../include/linux/mm.h ../include/asm/segment.h
|
||||
read_write.o : read_write.c ../include/sys/stat.h ../include/sys/types.h \
|
||||
../include/errno.h ../include/linux/kernel.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/linux/mm.h \
|
||||
../include/signal.h ../include/asm/segment.h
|
||||
stat.o : stat.c ../include/errno.h ../include/sys/stat.h \
|
||||
../include/sys/types.h ../include/linux/fs.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/mm.h ../include/signal.h \
|
||||
../include/linux/kernel.h ../include/asm/segment.h
|
||||
super.o : super.c ../include/linux/config.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h \
|
||||
../include/asm/system.h ../include/errno.h ../include/sys/stat.h
|
||||
truncate.o : truncate.c ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/fs.h ../include/sys/types.h ../include/linux/mm.h \
|
||||
../include/signal.h ../include/sys/stat.h
|
||||
@ -1,168 +0,0 @@
|
||||
/*
|
||||
* linux/fs/bitmap.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/* bitmap.c contains the code that handles the inode and block bitmaps */
|
||||
#include <string.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
|
||||
#define clear_block(addr) \
|
||||
__asm__ __volatile__ ("cld\n\t" \
|
||||
"rep\n\t" \
|
||||
"stosl" \
|
||||
::"a" (0),"c" (BLOCK_SIZE/4),"D" ((long) (addr)))
|
||||
|
||||
#define set_bit(nr,addr) ({\
|
||||
register int res __asm__("ax"); \
|
||||
__asm__ __volatile__("btsl %2,%3\n\tsetb %%al": \
|
||||
"=a" (res):"0" (0),"r" (nr),"m" (*(addr))); \
|
||||
res;})
|
||||
|
||||
#define clear_bit(nr,addr) ({\
|
||||
register int res __asm__("ax"); \
|
||||
__asm__ __volatile__("btrl %2,%3\n\tsetnb %%al": \
|
||||
"=a" (res):"0" (0),"r" (nr),"m" (*(addr))); \
|
||||
res;})
|
||||
|
||||
#define find_first_zero(addr) ({ \
|
||||
int __res; \
|
||||
__asm__ __volatile__ ("cld\n" \
|
||||
"1:\tlodsl\n\t" \
|
||||
"notl %%eax\n\t" \
|
||||
"bsfl %%eax,%%edx\n\t" \
|
||||
"je 2f\n\t" \
|
||||
"addl %%edx,%%ecx\n\t" \
|
||||
"jmp 3f\n" \
|
||||
"2:\taddl $32,%%ecx\n\t" \
|
||||
"cmpl $8192,%%ecx\n\t" \
|
||||
"jl 1b\n" \
|
||||
"3:" \
|
||||
:"=c" (__res):"c" (0),"S" (addr)); \
|
||||
__res;})
|
||||
|
||||
void free_block(int dev, int block)
|
||||
{
|
||||
struct super_block * sb;
|
||||
struct buffer_head * bh;
|
||||
|
||||
if (!(sb = get_super(dev)))
|
||||
panic("trying to free block on nonexistent device");
|
||||
if (block < sb->s_firstdatazone || block >= sb->s_nzones)
|
||||
panic("trying to free block not in datazone");
|
||||
bh = get_hash_table(dev,block);
|
||||
if (bh) {
|
||||
if (bh->b_count != 1) {
|
||||
printk("trying to free block (%04x:%d), count=%d\n",
|
||||
dev,block,bh->b_count);
|
||||
return;
|
||||
}
|
||||
bh->b_dirt=0;
|
||||
bh->b_uptodate=0;
|
||||
brelse(bh);
|
||||
}
|
||||
block -= sb->s_firstdatazone - 1 ;
|
||||
if (clear_bit(block&8191,sb->s_zmap[block/8192]->b_data)) {
|
||||
printk("block (%04x:%d) ",dev,block+sb->s_firstdatazone-1);
|
||||
panic("free_block: bit already cleared");
|
||||
}
|
||||
sb->s_zmap[block/8192]->b_dirt = 1;
|
||||
}
|
||||
|
||||
int new_block(int dev)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
struct super_block * sb;
|
||||
int i,j;
|
||||
|
||||
if (!(sb = get_super(dev)))
|
||||
panic("trying to get new block from nonexistant device");
|
||||
j = 8192;
|
||||
for (i=0 ; i<8 ; i++)
|
||||
if (bh=sb->s_zmap[i])
|
||||
if ((j=find_first_zero(bh->b_data))<8192)
|
||||
break;
|
||||
if (i>=8 || !bh || j>=8192)
|
||||
return 0;
|
||||
if (set_bit(j,bh->b_data))
|
||||
panic("new_block: bit already set");
|
||||
bh->b_dirt = 1;
|
||||
j += i*8192 + sb->s_firstdatazone-1;
|
||||
if (j >= sb->s_nzones)
|
||||
return 0;
|
||||
if (!(bh=getblk(dev,j)))
|
||||
panic("new_block: cannot get block");
|
||||
if (bh->b_count != 1)
|
||||
panic("new block: count is != 1");
|
||||
clear_block(bh->b_data);
|
||||
bh->b_uptodate = 1;
|
||||
bh->b_dirt = 1;
|
||||
brelse(bh);
|
||||
return j;
|
||||
}
|
||||
|
||||
void free_inode(struct m_inode * inode)
|
||||
{
|
||||
struct super_block * sb;
|
||||
struct buffer_head * bh;
|
||||
|
||||
if (!inode)
|
||||
return;
|
||||
if (!inode->i_dev) {
|
||||
memset(inode,0,sizeof(*inode));
|
||||
return;
|
||||
}
|
||||
if (inode->i_count>1) {
|
||||
printk("trying to free inode with count=%d\n",inode->i_count);
|
||||
panic("free_inode");
|
||||
}
|
||||
if (inode->i_nlinks)
|
||||
panic("trying to free inode with links");
|
||||
if (!(sb = get_super(inode->i_dev)))
|
||||
panic("trying to free inode on nonexistent device");
|
||||
if (inode->i_num < 1 || inode->i_num > sb->s_ninodes)
|
||||
panic("trying to free inode 0 or nonexistant inode");
|
||||
if (!(bh=sb->s_imap[inode->i_num>>13]))
|
||||
panic("nonexistent imap in superblock");
|
||||
if (clear_bit(inode->i_num&8191,bh->b_data))
|
||||
printk("free_inode: bit already cleared.\n\r");
|
||||
bh->b_dirt = 1;
|
||||
memset(inode,0,sizeof(*inode));
|
||||
}
|
||||
|
||||
struct m_inode * new_inode(int dev)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
struct super_block * sb;
|
||||
struct buffer_head * bh;
|
||||
int i,j;
|
||||
|
||||
if (!(inode=get_empty_inode()))
|
||||
return NULL;
|
||||
if (!(sb = get_super(dev)))
|
||||
panic("new_inode with unknown device");
|
||||
j = 8192;
|
||||
for (i=0 ; i<8 ; i++)
|
||||
if (bh=sb->s_imap[i])
|
||||
if ((j=find_first_zero(bh->b_data))<8192)
|
||||
break;
|
||||
if (!bh || j >= 8192 || j+i*8192 > sb->s_ninodes) {
|
||||
iput(inode);
|
||||
return NULL;
|
||||
}
|
||||
if (set_bit(j,bh->b_data))
|
||||
panic("new_inode: bit already set");
|
||||
bh->b_dirt = 1;
|
||||
inode->i_count=1;
|
||||
inode->i_nlinks=1;
|
||||
inode->i_dev=dev;
|
||||
inode->i_uid=current->euid;
|
||||
inode->i_gid=current->egid;
|
||||
inode->i_dirt=1;
|
||||
inode->i_num = j + i*8192;
|
||||
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
|
||||
return inode;
|
||||
}
|
||||
Binary file not shown.
@ -1,73 +0,0 @@
|
||||
/*
|
||||
* linux/fs/block_dev.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/segment.h>
|
||||
#include <asm/system.h>
|
||||
|
||||
int block_write(int dev, long * pos, char * buf, int count)
|
||||
{
|
||||
int block = *pos >> BLOCK_SIZE_BITS;
|
||||
int offset = *pos & (BLOCK_SIZE-1);
|
||||
int chars;
|
||||
int written = 0;
|
||||
struct buffer_head * bh;
|
||||
register char * p;
|
||||
|
||||
while (count>0) {
|
||||
chars = BLOCK_SIZE - offset;
|
||||
if (chars > count)
|
||||
chars=count;
|
||||
if (chars == BLOCK_SIZE)
|
||||
bh = getblk(dev,block);
|
||||
else
|
||||
bh = breada(dev,block,block+1,block+2,-1);
|
||||
block++;
|
||||
if (!bh)
|
||||
return written?written:-EIO;
|
||||
p = offset + bh->b_data;
|
||||
offset = 0;
|
||||
*pos += chars;
|
||||
written += chars;
|
||||
count -= chars;
|
||||
while (chars-->0)
|
||||
*(p++) = get_fs_byte(buf++);
|
||||
bh->b_dirt = 1;
|
||||
brelse(bh);
|
||||
}
|
||||
return written;
|
||||
}
|
||||
|
||||
int block_read(int dev, unsigned long * pos, char * buf, int count)
|
||||
{
|
||||
int block = *pos >> BLOCK_SIZE_BITS;
|
||||
int offset = *pos & (BLOCK_SIZE-1);
|
||||
int chars;
|
||||
int read = 0;
|
||||
struct buffer_head * bh;
|
||||
register char * p;
|
||||
|
||||
while (count>0) {
|
||||
chars = BLOCK_SIZE-offset;
|
||||
if (chars > count)
|
||||
chars = count;
|
||||
if (!(bh = breada(dev,block,block+1,block+2,-1)))
|
||||
return read?read:-EIO;
|
||||
block++;
|
||||
p = offset + bh->b_data;
|
||||
offset = 0;
|
||||
*pos += chars;
|
||||
read += chars;
|
||||
count -= chars;
|
||||
while (chars-->0)
|
||||
put_fs_byte(*(p++),buf++);
|
||||
brelse(bh);
|
||||
}
|
||||
return read;
|
||||
}
|
||||
Binary file not shown.
@ -1,384 +0,0 @@
|
||||
/*
|
||||
* linux/fs/buffer.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* 'buffer.c' implements the buffer-cache functions. Race-conditions have
|
||||
* been avoided by NEVER letting a interrupt change a buffer (except for the
|
||||
* data, of course), but instead letting the caller do it. NOTE! As interrupts
|
||||
* can wake up a caller, some cli-sti sequences are needed to check for
|
||||
* sleep-on-calls. These should be extremely quick, though (I hope).
|
||||
*/
|
||||
|
||||
/*
|
||||
* NOTE! There is one discordant note here: checking floppies for
|
||||
* disk change. This is where it fits best, I think, as it should
|
||||
* invalidate changed floppy-disk-caches.
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
|
||||
extern void put_super(int dev);
|
||||
extern void invalidate_inodes(int dev);
|
||||
|
||||
extern int end;
|
||||
struct buffer_head * start_buffer = (struct buffer_head *) &end;
|
||||
struct buffer_head * hash_table[NR_HASH];
|
||||
static struct buffer_head * free_list;
|
||||
static struct task_struct * buffer_wait = NULL;
|
||||
int NR_BUFFERS = 0;
|
||||
|
||||
static inline void wait_on_buffer(struct buffer_head * bh)
|
||||
{
|
||||
cli();
|
||||
while (bh->b_lock)
|
||||
sleep_on(&bh->b_wait);
|
||||
sti();
|
||||
}
|
||||
|
||||
int sys_sync(void)
|
||||
{
|
||||
int i;
|
||||
struct buffer_head * bh;
|
||||
|
||||
sync_inodes(); /* write out inodes into buffers */
|
||||
bh = start_buffer;
|
||||
for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_dirt)
|
||||
ll_rw_block(WRITE,bh);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sync_dev(int dev)
|
||||
{
|
||||
int i;
|
||||
struct buffer_head * bh;
|
||||
|
||||
bh = start_buffer;
|
||||
for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
|
||||
if (bh->b_dev != dev)
|
||||
continue;
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_dev == dev && bh->b_dirt)
|
||||
ll_rw_block(WRITE,bh);
|
||||
}
|
||||
sync_inodes();
|
||||
bh = start_buffer;
|
||||
for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
|
||||
if (bh->b_dev != dev)
|
||||
continue;
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_dev == dev && bh->b_dirt)
|
||||
ll_rw_block(WRITE,bh);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void inline invalidate_buffers(int dev)
|
||||
{
|
||||
int i;
|
||||
struct buffer_head * bh;
|
||||
|
||||
bh = start_buffer;
|
||||
for (i=0 ; i<NR_BUFFERS ; i++,bh++) {
|
||||
if (bh->b_dev != dev)
|
||||
continue;
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_dev == dev)
|
||||
bh->b_uptodate = bh->b_dirt = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This routine checks whether a floppy has been changed, and
|
||||
* invalidates all buffer-cache-entries in that case. This
|
||||
* is a relatively slow routine, so we have to try to minimize using
|
||||
* it. Thus it is called only upon a 'mount' or 'open'. This
|
||||
* is the best way of combining speed and utility, I think.
|
||||
* People changing diskettes in the middle of an operation deserve
|
||||
* to loose :-)
|
||||
*
|
||||
* NOTE! Although currently this is only for floppies, the idea is
|
||||
* that any additional removable block-device will use this routine,
|
||||
* and that mount/open needn't know that floppies/whatever are
|
||||
* special.
|
||||
*/
|
||||
void check_disk_change(int dev)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (MAJOR(dev) != 2)
|
||||
return;
|
||||
if (!floppy_change(dev & 0x03))
|
||||
return;
|
||||
for (i=0 ; i<NR_SUPER ; i++)
|
||||
if (super_block[i].s_dev == dev)
|
||||
put_super(super_block[i].s_dev);
|
||||
invalidate_inodes(dev);
|
||||
invalidate_buffers(dev);
|
||||
}
|
||||
|
||||
#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
|
||||
#define hash(dev,block) hash_table[_hashfn(dev,block)]
|
||||
|
||||
static inline void remove_from_queues(struct buffer_head * bh)
|
||||
{
|
||||
/* remove from hash-queue */
|
||||
if (bh->b_next)
|
||||
bh->b_next->b_prev = bh->b_prev;
|
||||
if (bh->b_prev)
|
||||
bh->b_prev->b_next = bh->b_next;
|
||||
if (hash(bh->b_dev,bh->b_blocknr) == bh)
|
||||
hash(bh->b_dev,bh->b_blocknr) = bh->b_next;
|
||||
/* remove from free list */
|
||||
if (!(bh->b_prev_free) || !(bh->b_next_free))
|
||||
panic("Free block list corrupted");
|
||||
bh->b_prev_free->b_next_free = bh->b_next_free;
|
||||
bh->b_next_free->b_prev_free = bh->b_prev_free;
|
||||
if (free_list == bh)
|
||||
free_list = bh->b_next_free;
|
||||
}
|
||||
|
||||
static inline void insert_into_queues(struct buffer_head * bh)
|
||||
{
|
||||
/* put at end of free list */
|
||||
bh->b_next_free = free_list;
|
||||
bh->b_prev_free = free_list->b_prev_free;
|
||||
free_list->b_prev_free->b_next_free = bh;
|
||||
free_list->b_prev_free = bh;
|
||||
/* put the buffer in new hash-queue if it has a device */
|
||||
bh->b_prev = NULL;
|
||||
bh->b_next = NULL;
|
||||
if (!bh->b_dev)
|
||||
return;
|
||||
bh->b_next = hash(bh->b_dev,bh->b_blocknr);
|
||||
hash(bh->b_dev,bh->b_blocknr) = bh;
|
||||
bh->b_next->b_prev = bh;
|
||||
}
|
||||
|
||||
static struct buffer_head * find_buffer(int dev, int block)
|
||||
{
|
||||
struct buffer_head * tmp;
|
||||
|
||||
for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
|
||||
if (tmp->b_dev==dev && tmp->b_blocknr==block)
|
||||
return tmp;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Why like this, I hear you say... The reason is race-conditions.
|
||||
* As we don't lock buffers (unless we are readint them, that is),
|
||||
* something might happen to it while we sleep (ie a read-error
|
||||
* will force it bad). This shouldn't really happen currently, but
|
||||
* the code is ready.
|
||||
*/
|
||||
struct buffer_head * get_hash_table(int dev, int block)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
|
||||
for (;;) {
|
||||
if (!(bh=find_buffer(dev,block)))
|
||||
return NULL;
|
||||
bh->b_count++;
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_dev == dev && bh->b_blocknr == block)
|
||||
return bh;
|
||||
bh->b_count--;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, this is getblk, and it isn't very clear, again to hinder
|
||||
* race-conditions. Most of the code is seldom used, (ie repeating),
|
||||
* so it should be much more efficient than it looks.
|
||||
*
|
||||
* The algoritm is changed: hopefully better, and an elusive bug removed.
|
||||
*/
|
||||
#define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
|
||||
struct buffer_head * getblk(int dev,int block)
|
||||
{
|
||||
struct buffer_head * tmp, * bh;
|
||||
|
||||
repeat:
|
||||
if (bh = get_hash_table(dev,block))
|
||||
return bh;
|
||||
tmp = free_list;
|
||||
do {
|
||||
if (tmp->b_count)
|
||||
continue;
|
||||
if (!bh || BADNESS(tmp)<BADNESS(bh)) {
|
||||
bh = tmp;
|
||||
if (!BADNESS(tmp))
|
||||
break;
|
||||
}
|
||||
/* and repeat until we find something good */
|
||||
} while ((tmp = tmp->b_next_free) != free_list);
|
||||
if (!bh) {
|
||||
sleep_on(&buffer_wait);
|
||||
goto repeat;
|
||||
}
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_count)
|
||||
goto repeat;
|
||||
while (bh->b_dirt) {
|
||||
sync_dev(bh->b_dev);
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_count)
|
||||
goto repeat;
|
||||
}
|
||||
/* NOTE!! While we slept waiting for this block, somebody else might */
|
||||
/* already have added "this" block to the cache. check it */
|
||||
if (find_buffer(dev,block))
|
||||
goto repeat;
|
||||
/* OK, FINALLY we know that this buffer is the only one of it's kind, */
|
||||
/* and that it's unused (b_count=0), unlocked (b_lock=0), and clean */
|
||||
bh->b_count=1;
|
||||
bh->b_dirt=0;
|
||||
bh->b_uptodate=0;
|
||||
remove_from_queues(bh);
|
||||
bh->b_dev=dev;
|
||||
bh->b_blocknr=block;
|
||||
insert_into_queues(bh);
|
||||
return bh;
|
||||
}
|
||||
|
||||
void brelse(struct buffer_head * buf)
|
||||
{
|
||||
if (!buf)
|
||||
return;
|
||||
wait_on_buffer(buf);
|
||||
if (!(buf->b_count--))
|
||||
panic("Trying to free free buffer");
|
||||
wake_up(&buffer_wait);
|
||||
}
|
||||
|
||||
/*
|
||||
* bread() reads a specified block and returns the buffer that contains
|
||||
* it. It returns NULL if the block was unreadable.
|
||||
*/
|
||||
struct buffer_head * bread(int dev,int block)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
|
||||
if (!(bh=getblk(dev,block)))
|
||||
panic("bread: getblk returned NULL\n");
|
||||
if (bh->b_uptodate)
|
||||
return bh;
|
||||
ll_rw_block(READ,bh);
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_uptodate)
|
||||
return bh;
|
||||
brelse(bh);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#define COPYBLK(from,to) \
|
||||
__asm__("cld\n\t" \
|
||||
"rep\n\t" \
|
||||
"movsl\n\t" \
|
||||
::"c" (BLOCK_SIZE/4),"S" (from),"D" (to) \
|
||||
)
|
||||
|
||||
/*
|
||||
* bread_page reads four buffers into memory at the desired address. It's
|
||||
* a function of its own, as there is some speed to be got by reading them
|
||||
* all at the same time, not waiting for one to be read, and then another
|
||||
* etc.
|
||||
*/
|
||||
void bread_page(unsigned long address,int dev,int b[4])
|
||||
{
|
||||
struct buffer_head * bh[4];
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<4 ; i++)
|
||||
if (b[i]) {
|
||||
if (bh[i] = getblk(dev,b[i]))
|
||||
if (!bh[i]->b_uptodate)
|
||||
ll_rw_block(READ,bh[i]);
|
||||
} else
|
||||
bh[i] = NULL;
|
||||
for (i=0 ; i<4 ; i++,address += BLOCK_SIZE)
|
||||
if (bh[i]) {
|
||||
wait_on_buffer(bh[i]);
|
||||
if (bh[i]->b_uptodate)
|
||||
COPYBLK((unsigned long) bh[i]->b_data,address);
|
||||
brelse(bh[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, breada can be used as bread, but additionally to mark other
|
||||
* blocks for reading as well. End the argument list with a negative
|
||||
* number.
|
||||
*/
|
||||
struct buffer_head * breada(int dev,int first, ...)
|
||||
{
|
||||
va_list args;
|
||||
struct buffer_head * bh, *tmp;
|
||||
|
||||
va_start(args,first);
|
||||
if (!(bh=getblk(dev,first)))
|
||||
panic("bread: getblk returned NULL\n");
|
||||
if (!bh->b_uptodate)
|
||||
ll_rw_block(READ,bh);
|
||||
while ((first=va_arg(args,int))>=0) {
|
||||
tmp=getblk(dev,first);
|
||||
if (tmp) {
|
||||
if (!tmp->b_uptodate)
|
||||
ll_rw_block(READA,bh);
|
||||
tmp->b_count--;
|
||||
}
|
||||
}
|
||||
va_end(args);
|
||||
wait_on_buffer(bh);
|
||||
if (bh->b_uptodate)
|
||||
return bh;
|
||||
brelse(bh);
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
void buffer_init(long buffer_end)
|
||||
{
|
||||
struct buffer_head * h = start_buffer;
|
||||
void * b;
|
||||
int i;
|
||||
|
||||
if (buffer_end == 1<<20)
|
||||
b = (void *) (640*1024);
|
||||
else
|
||||
b = (void *) buffer_end;
|
||||
while ( (b -= BLOCK_SIZE) >= ((void *) (h+1)) ) {
|
||||
h->b_dev = 0;
|
||||
h->b_dirt = 0;
|
||||
h->b_count = 0;
|
||||
h->b_lock = 0;
|
||||
h->b_uptodate = 0;
|
||||
h->b_wait = NULL;
|
||||
h->b_next = NULL;
|
||||
h->b_prev = NULL;
|
||||
h->b_data = (char *) b;
|
||||
h->b_prev_free = h-1;
|
||||
h->b_next_free = h+1;
|
||||
h++;
|
||||
NR_BUFFERS++;
|
||||
if (b == (void *) 0x100000)
|
||||
b = (void *) 0xA0000;
|
||||
}
|
||||
h--;
|
||||
free_list = start_buffer;
|
||||
free_list->b_prev_free = h;
|
||||
h->b_next_free = free_list;
|
||||
for (i=0;i<NR_HASH;i++)
|
||||
hash_table[i]=NULL;
|
||||
}
|
||||
Binary file not shown.
@ -1,104 +0,0 @@
|
||||
/*
|
||||
* linux/fs/char_dev.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
|
||||
#include <asm/segment.h>
|
||||
#include <asm/io.h>
|
||||
|
||||
extern int tty_read(unsigned minor,char * buf,int count);
|
||||
extern int tty_write(unsigned minor,char * buf,int count);
|
||||
|
||||
typedef (*crw_ptr)(int rw,unsigned minor,char * buf,int count,off_t * pos);
|
||||
|
||||
static int rw_ttyx(int rw,unsigned minor,char * buf,int count,off_t * pos)
|
||||
{
|
||||
return ((rw==READ)?tty_read(minor,buf,count):
|
||||
tty_write(minor,buf,count));
|
||||
}
|
||||
|
||||
static int rw_tty(int rw,unsigned minor,char * buf,int count, off_t * pos)
|
||||
{
|
||||
if (current->tty<0)
|
||||
return -EPERM;
|
||||
return rw_ttyx(rw,current->tty,buf,count,pos);
|
||||
}
|
||||
|
||||
static int rw_ram(int rw,char * buf, int count, off_t *pos)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static int rw_mem(int rw,char * buf, int count, off_t * pos)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static int rw_kmem(int rw,char * buf, int count, off_t * pos)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static int rw_port(int rw,char * buf, int count, off_t * pos)
|
||||
{
|
||||
int i=*pos;
|
||||
|
||||
while (count-->0 && i<65536) {
|
||||
if (rw==READ)
|
||||
put_fs_byte(inb(i),buf++);
|
||||
else
|
||||
outb(get_fs_byte(buf++),i);
|
||||
i++;
|
||||
}
|
||||
i -= *pos;
|
||||
*pos += i;
|
||||
return i;
|
||||
}
|
||||
|
||||
static int rw_memory(int rw, unsigned minor, char * buf, int count, off_t * pos)
|
||||
{
|
||||
switch(minor) {
|
||||
case 0:
|
||||
return rw_ram(rw,buf,count,pos);
|
||||
case 1:
|
||||
return rw_mem(rw,buf,count,pos);
|
||||
case 2:
|
||||
return rw_kmem(rw,buf,count,pos);
|
||||
case 3:
|
||||
return (rw==READ)?0:count; /* rw_null */
|
||||
case 4:
|
||||
return rw_port(rw,buf,count,pos);
|
||||
default:
|
||||
return -EIO;
|
||||
}
|
||||
}
|
||||
|
||||
#define NRDEVS ((sizeof (crw_table))/(sizeof (crw_ptr)))
|
||||
|
||||
static crw_ptr crw_table[]={
|
||||
NULL, /* nodev */
|
||||
rw_memory, /* /dev/mem etc */
|
||||
NULL, /* /dev/fd */
|
||||
NULL, /* /dev/hd */
|
||||
rw_ttyx, /* /dev/ttyx */
|
||||
rw_tty, /* /dev/tty */
|
||||
NULL, /* /dev/lp */
|
||||
NULL}; /* unnamed pipes */
|
||||
|
||||
int rw_char(int rw,int dev, char * buf, int count, off_t * pos)
|
||||
{
|
||||
crw_ptr call_addr;
|
||||
|
||||
if (MAJOR(dev)>=NRDEVS)
|
||||
return -ENODEV;
|
||||
if (!(call_addr=crw_table[MAJOR(dev)]))
|
||||
return -ENODEV;
|
||||
return call_addr(rw,MINOR(dev),buf,count,pos);
|
||||
}
|
||||
Binary file not shown.
@ -1,537 +0,0 @@
|
||||
/*
|
||||
* linux/fs/exec.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* #!-checking implemented by tytso.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Demand-loading implemented 01.12.91 - no need to read anything but
|
||||
* the header into memory. The inode of the executable is put into
|
||||
* "current->executable", and page faults do the actual loading. Clean.
|
||||
*
|
||||
* Once more I can proudly say that linux stood up to being changed: it
|
||||
* was less than 2 hours work to get demand-loading completely implemented.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <a.out.h>
|
||||
|
||||
#include <linux/fs.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/mm.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
extern int sys_exit(int exit_code);
|
||||
extern int sys_close(int fd);
|
||||
|
||||
/*
|
||||
* MAX_ARG_PAGES defines the number of pages allocated for arguments
|
||||
* and envelope for the new program. 32 should suffice, this gives
|
||||
* a maximum env+arg of 128kB !
|
||||
*/
|
||||
#define MAX_ARG_PAGES 32
|
||||
|
||||
|
||||
int sys_uselib()
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
/*
|
||||
* create_tables() parses the env- and arg-strings in new user
|
||||
* memory and creates the pointer tables from them, and puts their
|
||||
* addresses on the "stack", returning the new stack pointer value.
|
||||
*/
|
||||
static unsigned long * create_tables(char * p,int argc,int envc)
|
||||
{
|
||||
unsigned long *argv,*envp;
|
||||
unsigned long * sp;
|
||||
|
||||
sp = (unsigned long *) (0xfffffffc & (unsigned long) p);
|
||||
sp -= envc+1;
|
||||
envp = sp;
|
||||
sp -= argc+1;
|
||||
argv = sp;
|
||||
put_fs_long((unsigned long)envp,--sp);
|
||||
put_fs_long((unsigned long)argv,--sp);
|
||||
put_fs_long((unsigned long)argc,--sp);
|
||||
while (argc-->0) {
|
||||
put_fs_long((unsigned long) p,argv++);
|
||||
while (get_fs_byte(p++)) /* nothing */ ;
|
||||
}
|
||||
put_fs_long(0,argv);
|
||||
while (envc-->0) {
|
||||
put_fs_long((unsigned long) p,envp++);
|
||||
while (get_fs_byte(p++)) /* nothing */ ;
|
||||
}
|
||||
put_fs_long(0,envp);
|
||||
return sp;
|
||||
}
|
||||
|
||||
/*
|
||||
* count() counts the number of arguments/envelopes
|
||||
*/
|
||||
static int count(char ** argv)
|
||||
{
|
||||
int i=0;
|
||||
char ** tmp;
|
||||
|
||||
if (tmp = argv)
|
||||
while (get_fs_long((unsigned long *) (tmp++)))
|
||||
i++;
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'copy_string()' copies argument/envelope strings from user
|
||||
* memory to free pages in kernel mem. These are in a format ready
|
||||
* to be put directly into the top of new user memory.
|
||||
*
|
||||
* Modified by TYT, 11/24/91 to add the from_kmem argument, which specifies
|
||||
* whether the string and the string array are from user or kernel segments:
|
||||
*
|
||||
* from_kmem argv * argv **
|
||||
* 0 user space user space
|
||||
* 1 kernel space user space
|
||||
* 2 kernel space kernel space
|
||||
*
|
||||
* We do this by playing games with the fs segment register. Since it
|
||||
* it is expensive to load a segment register, we try to avoid calling
|
||||
* set_fs() unless we absolutely have to.
|
||||
*/
|
||||
static unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
|
||||
unsigned long p, int from_kmem)
|
||||
{
|
||||
char *tmp, *pag;
|
||||
int len, offset = 0;
|
||||
unsigned long old_fs, new_fs;
|
||||
|
||||
if (!p)
|
||||
return 0; /* bullet-proofing */
|
||||
new_fs = get_ds();
|
||||
old_fs = get_fs();
|
||||
if (from_kmem==2)
|
||||
set_fs(new_fs);
|
||||
while (argc-- > 0) {
|
||||
if (from_kmem == 1)
|
||||
set_fs(new_fs);
|
||||
if (!(tmp = (char *)get_fs_long(((unsigned long *)argv)+argc)))
|
||||
panic("argc is wrong");
|
||||
if (from_kmem == 1)
|
||||
set_fs(old_fs);
|
||||
len=0; /* remember zero-padding */
|
||||
do {
|
||||
len++;
|
||||
} while (get_fs_byte(tmp++));
|
||||
if (p-len < 0) { /* this shouldn't happen - 128kB */
|
||||
set_fs(old_fs);
|
||||
return 0;
|
||||
}
|
||||
while (len) {
|
||||
--p; --tmp; --len;
|
||||
if (--offset < 0) {
|
||||
offset = p % PAGE_SIZE;
|
||||
if (from_kmem==2)
|
||||
set_fs(old_fs);
|
||||
if (!(pag = (char *) page[p/PAGE_SIZE]) &&
|
||||
!(pag = (char *) (page[p/PAGE_SIZE] =
|
||||
(unsigned long *) get_free_page())))
|
||||
return 0;
|
||||
if (from_kmem==2)
|
||||
set_fs(new_fs);
|
||||
|
||||
}
|
||||
*(pag + offset) = get_fs_byte(tmp);
|
||||
}
|
||||
}
|
||||
if (from_kmem==2)
|
||||
set_fs(old_fs);
|
||||
return p;
|
||||
}
|
||||
|
||||
static unsigned long change_ldt(unsigned long text_size,unsigned long * page)
|
||||
{
|
||||
unsigned long code_limit,data_limit,code_base,data_base;
|
||||
int i;
|
||||
|
||||
code_limit = text_size+PAGE_SIZE -1;
|
||||
code_limit &= 0xFFFFF000;
|
||||
data_limit = 0x4000000;
|
||||
code_base = get_base(current->ldt[1]);
|
||||
data_base = code_base;
|
||||
set_base(current->ldt[1],code_base);
|
||||
set_limit(current->ldt[1],code_limit);
|
||||
set_base(current->ldt[2],data_base);
|
||||
set_limit(current->ldt[2],data_limit);
|
||||
/* make sure fs points to the NEW data segment */
|
||||
__asm__("pushl $0x17\n\tpop %%fs"::);
|
||||
data_base += data_limit;
|
||||
for (i=MAX_ARG_PAGES-1 ; i>=0 ; i--) {
|
||||
data_base -= PAGE_SIZE;
|
||||
if (page[i])
|
||||
put_page(page[i],data_base);
|
||||
}
|
||||
return data_limit;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'do_execve()' executes a new program.
|
||||
*/
|
||||
int do_execve(unsigned long * eip,long tmp,char * filename,
|
||||
char ** argv, char ** envp)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
struct buffer_head * bh;
|
||||
struct exec ex;
|
||||
unsigned long page[MAX_ARG_PAGES];
|
||||
int i,argc,envc;
|
||||
int e_uid, e_gid;
|
||||
int retval;
|
||||
int sh_bang = 0;
|
||||
unsigned long p=PAGE_SIZE*MAX_ARG_PAGES-4;
|
||||
|
||||
if ((0xffff & eip[1]) != 0x000f)
|
||||
panic("execve called from supervisor mode");
|
||||
for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */
|
||||
page[i]=0;
|
||||
if (!(inode=namei(filename))) /* get executables inode */
|
||||
return -ENOENT;
|
||||
argc = count(argv);
|
||||
envc = count(envp);
|
||||
|
||||
restart_interp:
|
||||
if (!S_ISREG(inode->i_mode)) { /* must be regular file */
|
||||
retval = -EACCES;
|
||||
goto exec_error2;
|
||||
}
|
||||
i = inode->i_mode;
|
||||
e_uid = (i & S_ISUID) ? inode->i_uid : current->euid;
|
||||
e_gid = (i & S_ISGID) ? inode->i_gid : current->egid;
|
||||
if (current->euid == inode->i_uid)
|
||||
i >>= 6;
|
||||
else if (current->egid == inode->i_gid)
|
||||
i >>= 3;
|
||||
if (!(i & 1) &&
|
||||
!((inode->i_mode & 0111) && suser())) {
|
||||
retval = -ENOEXEC;
|
||||
goto exec_error2;
|
||||
}
|
||||
if (!(bh = bread(inode->i_dev,inode->i_zone[0]))) {
|
||||
retval = -EACCES;
|
||||
goto exec_error2;
|
||||
}
|
||||
ex = *((struct exec *) bh->b_data); /* read exec-header */
|
||||
if ((bh->b_data[0] == '#') && (bh->b_data[1] == '!') && (!sh_bang)) {
|
||||
/*
|
||||
* This section does the #! interpretation.
|
||||
* Sorta complicated, but hopefully it will work. -TYT
|
||||
*/
|
||||
|
||||
char buf[1023], *cp, *interp, *i_name, *i_arg;
|
||||
unsigned long old_fs;
|
||||
|
||||
strncpy(buf, bh->b_data+2, 1022);
|
||||
brelse(bh);
|
||||
iput(inode);
|
||||
buf[1022] = '\0';
|
||||
if (cp = strchr(buf, '\n')) {
|
||||
*cp = '\0';
|
||||
for (cp = buf; (*cp == ' ') || (*cp == '\t'); cp++);
|
||||
}
|
||||
if (!cp || *cp == '\0') {
|
||||
retval = -ENOEXEC; /* No interpreter name found */
|
||||
goto exec_error1;
|
||||
}
|
||||
interp = i_name = cp;
|
||||
i_arg = 0;
|
||||
for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
|
||||
if (*cp == '/')
|
||||
i_name = cp+1;
|
||||
}
|
||||
if (*cp) {
|
||||
*cp++ = '\0';
|
||||
i_arg = cp;
|
||||
}
|
||||
/*
|
||||
* OK, we've parsed out the interpreter name and
|
||||
* (optional) argument.
|
||||
*/
|
||||
if (sh_bang++ == 0) {
|
||||
p = copy_strings(envc, envp, page, p, 0);
|
||||
p = copy_strings(--argc, argv+1, page, p, 0);
|
||||
}
|
||||
/*
|
||||
* Splice in (1) the interpreter's name for argv[0]
|
||||
* (2) (optional) argument to interpreter
|
||||
* (3) filename of shell script
|
||||
*
|
||||
* This is done in reverse order, because of how the
|
||||
* user environment and arguments are stored.
|
||||
*/
|
||||
p = copy_strings(1, &filename, page, p, 1);
|
||||
argc++;
|
||||
if (i_arg) {
|
||||
p = copy_strings(1, &i_arg, page, p, 2);
|
||||
argc++;
|
||||
}
|
||||
p = copy_strings(1, &i_name, page, p, 2);
|
||||
argc++;
|
||||
if (!p) {
|
||||
retval = -ENOMEM;
|
||||
goto exec_error1;
|
||||
}
|
||||
/*
|
||||
* OK, now restart the process with the interpreter's inode.
|
||||
*/
|
||||
old_fs = get_fs();
|
||||
set_fs(get_ds());
|
||||
if (!(inode=namei(interp))) { /* get executables inode */
|
||||
set_fs(old_fs);
|
||||
retval = -ENOENT;
|
||||
goto exec_error1;
|
||||
}
|
||||
set_fs(old_fs);
|
||||
goto restart_interp;
|
||||
}
|
||||
brelse(bh);
|
||||
if (N_MAGIC(ex) != ZMAGIC || ex.a_trsize || ex.a_drsize ||
|
||||
ex.a_text+ex.a_data+ex.a_bss>0x3000000 ||
|
||||
inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
|
||||
retval = -ENOEXEC;
|
||||
goto exec_error2;
|
||||
}
|
||||
if (N_TXTOFF(ex) != BLOCK_SIZE) {
|
||||
printk("%s: N_TXTOFF != BLOCK_SIZE. See a.out.h.", filename);
|
||||
retval = -ENOEXEC;
|
||||
goto exec_error2;
|
||||
}
|
||||
if (!sh_bang) {
|
||||
p = copy_strings(envc,envp,page,p,0);
|
||||
p = copy_strings(argc,argv,page,p,0);
|
||||
if (!p) {
|
||||
retval = -ENOMEM;
|
||||
goto exec_error2;
|
||||
}
|
||||
}
|
||||
/* OK, This is the point of no return */
|
||||
if (current->executable)
|
||||
iput(current->executable);
|
||||
current->executable = inode;
|
||||
for (i=0 ; i<32 ; i++)
|
||||
current->sigaction[i].sa_handler = NULL;
|
||||
for (i=0 ; i<NR_OPEN ; i++)
|
||||
if ((current->close_on_exec>>i)&1)
|
||||
sys_close(i);
|
||||
current->close_on_exec = 0;
|
||||
free_page_tables(get_base(current->ldt[1]),get_limit(0x0f));
|
||||
free_page_tables(get_base(current->ldt[2]),get_limit(0x17));
|
||||
if (last_task_used_math == current)
|
||||
last_task_used_math = NULL;
|
||||
current->used_math = 0;
|
||||
p += change_ldt(ex.a_text,page)-MAX_ARG_PAGES*PAGE_SIZE;
|
||||
p = (unsigned long) create_tables((char *)p,argc,envc);
|
||||
current->brk = ex.a_bss +
|
||||
(current->end_data = ex.a_data +
|
||||
(current->end_code = ex.a_text));
|
||||
current->start_stack = p & 0xfffff000;
|
||||
current->euid = e_uid;
|
||||
current->egid = e_gid;
|
||||
i = ex.a_text+ex.a_data;
|
||||
while (i&0xfff)
|
||||
put_fs_byte(0,(char *) (i++));
|
||||
eip[0] = ex.a_entry; /* eip, magic happens :-) */
|
||||
eip[3] = p; /* stack pointer */
|
||||
return 0;
|
||||
exec_error2:
|
||||
iput(inode);
|
||||
exec_error1:
|
||||
for (i=0 ; i<MAX_ARG_PAGES ; i++)
|
||||
free_page(page[i]);
|
||||
return(retval);
|
||||
}
|
||||
int do_execve2(unsigned long * eip,long tmp,char * filename,
|
||||
char ** argv, char ** envp)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
struct buffer_head * bh;
|
||||
struct exec ex;
|
||||
unsigned long page[MAX_ARG_PAGES];
|
||||
int i,argc,envc;
|
||||
int e_uid, e_gid;
|
||||
int retval;
|
||||
int sh_bang = 0;
|
||||
unsigned long p=PAGE_SIZE*MAX_ARG_PAGES-4;
|
||||
|
||||
if ((0xffff & eip[1]) != 0x000f)
|
||||
panic("execve called from supervisor mode");
|
||||
for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */
|
||||
page[i]=0;
|
||||
if (!(inode=namei(filename))) /* get executables inode */
|
||||
return -ENOENT;
|
||||
argc = count(argv);
|
||||
envc = count(envp);
|
||||
|
||||
restart_interp:
|
||||
if (!S_ISREG(inode->i_mode)) { /* must be regular file */
|
||||
retval = -EACCES;
|
||||
goto exec_error2;
|
||||
}
|
||||
i = inode->i_mode;
|
||||
e_uid = (i & S_ISUID) ? inode->i_uid : current->euid;
|
||||
e_gid = (i & S_ISGID) ? inode->i_gid : current->egid;
|
||||
if (current->euid == inode->i_uid)
|
||||
i >>= 6;
|
||||
else if (current->egid == inode->i_gid)
|
||||
i >>= 3;
|
||||
if (!(i & 1) &&
|
||||
!((inode->i_mode & 0111) && suser())) {
|
||||
retval = -ENOEXEC;
|
||||
goto exec_error2;
|
||||
}
|
||||
if (!(bh = bread(inode->i_dev,inode->i_zone[0]))) {
|
||||
retval = -EACCES;
|
||||
goto exec_error2;
|
||||
}
|
||||
ex = *((struct exec *) bh->b_data); /* read exec-header */
|
||||
if ((bh->b_data[0] == '#') && (bh->b_data[1] == '!') && (!sh_bang)) {
|
||||
/*
|
||||
* This section does the #! interpretation.
|
||||
* Sorta complicated, but hopefully it will work. -TYT
|
||||
*/
|
||||
|
||||
char buf[1023], *cp, *interp, *i_name, *i_arg;
|
||||
unsigned long old_fs;
|
||||
|
||||
strncpy(buf, bh->b_data+2, 1022);
|
||||
brelse(bh);
|
||||
iput(inode);
|
||||
buf[1022] = '\0';
|
||||
if (cp = strchr(buf, '\n')) {
|
||||
*cp = '\0';
|
||||
for (cp = buf; (*cp == ' ') || (*cp == '\t'); cp++);
|
||||
}
|
||||
if (!cp || *cp == '\0') {
|
||||
retval = -ENOEXEC; /* No interpreter name found */
|
||||
goto exec_error1;
|
||||
}
|
||||
interp = i_name = cp;
|
||||
i_arg = 0;
|
||||
for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
|
||||
if (*cp == '/')
|
||||
i_name = cp+1;
|
||||
}
|
||||
if (*cp) {
|
||||
*cp++ = '\0';
|
||||
i_arg = cp;
|
||||
}
|
||||
/*
|
||||
* OK, we've parsed out the interpreter name and
|
||||
* (optional) argument.
|
||||
*/
|
||||
if (sh_bang++ == 0) {
|
||||
p = copy_strings(envc, envp, page, p, 0);
|
||||
p = copy_strings(--argc, argv+1, page, p, 0);
|
||||
}
|
||||
/*
|
||||
* Splice in (1) the interpreter's name for argv[0]
|
||||
* (2) (optional) argument to interpreter
|
||||
* (3) filename of shell script
|
||||
*
|
||||
* This is done in reverse order, because of how the
|
||||
* user environment and arguments are stored.
|
||||
*/
|
||||
p = copy_strings(1, &filename, page, p, 1);
|
||||
argc++;
|
||||
if (i_arg) {
|
||||
p = copy_strings(1, &i_arg, page, p, 2);
|
||||
argc++;
|
||||
}
|
||||
p = copy_strings(1, &i_name, page, p, 2);
|
||||
argc++;
|
||||
if (!p) {
|
||||
retval = -ENOMEM;
|
||||
goto exec_error1;
|
||||
}
|
||||
/*
|
||||
* OK, now restart the process with the interpreter's inode.
|
||||
*/
|
||||
old_fs = get_fs();
|
||||
set_fs(get_ds());
|
||||
if (!(inode=namei(interp))) { /* get executables inode */
|
||||
set_fs(old_fs);
|
||||
retval = -ENOENT;
|
||||
goto exec_error1;
|
||||
}
|
||||
set_fs(old_fs);
|
||||
goto restart_interp;
|
||||
}
|
||||
brelse(bh);
|
||||
if (N_MAGIC(ex) != ZMAGIC || ex.a_trsize || ex.a_drsize ||
|
||||
ex.a_text+ex.a_data+ex.a_bss>0x3000000 ||
|
||||
inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
|
||||
retval = -ENOEXEC;
|
||||
goto exec_error2;
|
||||
}
|
||||
if (N_TXTOFF(ex) != BLOCK_SIZE) {
|
||||
printk("%s: N_TXTOFF != BLOCK_SIZE. See a.out.h.", filename);
|
||||
retval = -ENOEXEC;
|
||||
goto exec_error2;
|
||||
}
|
||||
if (!sh_bang) {
|
||||
p = copy_strings(envc,envp,page,p,0);
|
||||
p = copy_strings(argc,argv,page,p,0);
|
||||
if (!p) {
|
||||
retval = -ENOMEM;
|
||||
goto exec_error2;
|
||||
}
|
||||
}
|
||||
/* OK, This is the point of no return */
|
||||
if (current->executable)
|
||||
iput(current->executable);
|
||||
current->executable = inode;
|
||||
for (i=0 ; i<32 ; i++)
|
||||
current->sigaction[i].sa_handler = NULL;
|
||||
for (i=0 ; i<NR_OPEN ; i++)
|
||||
if ((current->close_on_exec>>i)&1)
|
||||
sys_close(i);
|
||||
current->close_on_exec = 0;
|
||||
free_page_tables(get_base(current->ldt[1]),get_limit(0x0f));
|
||||
free_page_tables(get_base(current->ldt[2]),get_limit(0x17));
|
||||
if (last_task_used_math == current)
|
||||
last_task_used_math = NULL;
|
||||
current->used_math = 0;
|
||||
p += change_ldt(ex.a_text,page)-MAX_ARG_PAGES*PAGE_SIZE;
|
||||
p = (unsigned long) create_tables((char *)p,argc,envc);
|
||||
current->brk = ex.a_bss +
|
||||
(current->end_data = ex.a_data +
|
||||
(current->end_code = ex.a_text));
|
||||
current->start_stack = p & 0xfffff000;
|
||||
current->euid = e_uid;
|
||||
current->egid = e_gid;
|
||||
i = ex.a_text+ex.a_data;
|
||||
while (i&0xfff)
|
||||
put_fs_byte(0,(char *) (i++));
|
||||
eip[0] = ex.a_entry; /* eip, magic happens :-) */
|
||||
eip[3] = p; /* stack pointer */
|
||||
unsigned long offset,end;
|
||||
end=(current->brk-1)&(0xfffff000);
|
||||
for(offset=0;offset<=end;offset+=4096){
|
||||
do_no_page(current->start_code+offset);
|
||||
}
|
||||
|
||||
return 0;
|
||||
exec_error2:
|
||||
iput(inode);
|
||||
exec_error1:
|
||||
for (i=0 ; i<MAX_ARG_PAGES ; i++)
|
||||
free_page(page[i]);
|
||||
return(retval);
|
||||
}
|
||||
@ -1,75 +0,0 @@
|
||||
/*
|
||||
* linux/fs/fcntl.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
extern int sys_close(int fd);
|
||||
|
||||
static int dupfd(unsigned int fd, unsigned int arg)
|
||||
{
|
||||
if (fd >= NR_OPEN || !current->filp[fd])
|
||||
return -EBADF;
|
||||
if (arg >= NR_OPEN)
|
||||
return -EINVAL;
|
||||
while (arg < NR_OPEN)
|
||||
if (current->filp[arg])
|
||||
arg++;
|
||||
else
|
||||
break;
|
||||
if (arg >= NR_OPEN)
|
||||
return -EMFILE;
|
||||
current->close_on_exec &= ~(1<<arg);
|
||||
(current->filp[arg] = current->filp[fd])->f_count++;
|
||||
return arg;
|
||||
}
|
||||
|
||||
int sys_dup2(unsigned int oldfd, unsigned int newfd)
|
||||
{
|
||||
sys_close(newfd);
|
||||
return dupfd(oldfd,newfd);
|
||||
}
|
||||
|
||||
int sys_dup(unsigned int fildes)
|
||||
{
|
||||
return dupfd(fildes,0);
|
||||
}
|
||||
|
||||
int sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct file * filp;
|
||||
|
||||
if (fd >= NR_OPEN || !(filp = current->filp[fd]))
|
||||
return -EBADF;
|
||||
switch (cmd) {
|
||||
case F_DUPFD:
|
||||
return dupfd(fd,arg);
|
||||
case F_GETFD:
|
||||
return (current->close_on_exec>>fd)&1;
|
||||
case F_SETFD:
|
||||
if (arg&1)
|
||||
current->close_on_exec |= (1<<fd);
|
||||
else
|
||||
current->close_on_exec &= ~(1<<fd);
|
||||
return 0;
|
||||
case F_GETFL:
|
||||
return filp->f_flags;
|
||||
case F_SETFL:
|
||||
filp->f_flags &= ~(O_APPEND | O_NONBLOCK);
|
||||
filp->f_flags |= arg & (O_APPEND | O_NONBLOCK);
|
||||
return 0;
|
||||
case F_GETLK: case F_SETLK: case F_SETLKW:
|
||||
return -1;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
Binary file not shown.
@ -1,90 +0,0 @@
|
||||
/*
|
||||
* linux/fs/file_dev.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
#define MIN(a,b) (((a)<(b))?(a):(b))
|
||||
#define MAX(a,b) (((a)>(b))?(a):(b))
|
||||
|
||||
int file_read(struct m_inode * inode, struct file * filp, char * buf, int count)
|
||||
{
|
||||
int left,chars,nr;
|
||||
struct buffer_head * bh;
|
||||
|
||||
if ((left=count)<=0)
|
||||
return 0;
|
||||
while (left) {
|
||||
if (nr = bmap(inode,(filp->f_pos)/BLOCK_SIZE)) {
|
||||
if (!(bh=bread(inode->i_dev,nr)))
|
||||
break;
|
||||
} else
|
||||
bh = NULL;
|
||||
nr = filp->f_pos % BLOCK_SIZE;
|
||||
chars = MIN( BLOCK_SIZE-nr , left );
|
||||
filp->f_pos += chars;
|
||||
left -= chars;
|
||||
if (bh) {
|
||||
char * p = nr + bh->b_data;
|
||||
while (chars-->0)
|
||||
put_fs_byte(*(p++),buf++);
|
||||
brelse(bh);
|
||||
} else {
|
||||
while (chars-->0)
|
||||
put_fs_byte(0,buf++);
|
||||
}
|
||||
}
|
||||
inode->i_atime = CURRENT_TIME;
|
||||
return (count-left)?(count-left):-ERROR;
|
||||
}
|
||||
|
||||
int file_write(struct m_inode * inode, struct file * filp, char * buf, int count)
|
||||
{
|
||||
off_t pos;
|
||||
int block,c;
|
||||
struct buffer_head * bh;
|
||||
char * p;
|
||||
int i=0;
|
||||
|
||||
/*
|
||||
* ok, append may not work when many processes are writing at the same time
|
||||
* but so what. That way leads to madness anyway.
|
||||
*/
|
||||
if (filp->f_flags & O_APPEND)
|
||||
pos = inode->i_size;
|
||||
else
|
||||
pos = filp->f_pos;
|
||||
while (i<count) {
|
||||
if (!(block = create_block(inode,pos/BLOCK_SIZE)))
|
||||
break;
|
||||
if (!(bh=bread(inode->i_dev,block)))
|
||||
break;
|
||||
c = pos % BLOCK_SIZE;
|
||||
p = c + bh->b_data;
|
||||
bh->b_dirt = 1;
|
||||
c = BLOCK_SIZE-c;
|
||||
if (c > count-i) c = count-i;
|
||||
pos += c;
|
||||
if (pos > inode->i_size) {
|
||||
inode->i_size = pos;
|
||||
inode->i_dirt = 1;
|
||||
}
|
||||
i += c;
|
||||
while (c-->0)
|
||||
*(p++) = get_fs_byte(buf++);
|
||||
brelse(bh);
|
||||
}
|
||||
inode->i_mtime = CURRENT_TIME;
|
||||
if (!(filp->f_flags & O_APPEND)) {
|
||||
filp->f_pos = pos;
|
||||
inode->i_ctime = CURRENT_TIME;
|
||||
}
|
||||
return (i?i:-1);
|
||||
}
|
||||
Binary file not shown.
@ -1,9 +0,0 @@
|
||||
/*
|
||||
* linux/fs/file_table.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <linux/fs.h>
|
||||
|
||||
struct file file_table[NR_FILE];
|
||||
Binary file not shown.
@ -1,340 +0,0 @@
|
||||
/*
|
||||
* linux/fs/inode.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/mm.h>
|
||||
#include <asm/system.h>
|
||||
|
||||
struct m_inode inode_table[NR_INODE]={{0,},};
|
||||
|
||||
static void read_inode(struct m_inode * inode);
|
||||
static void write_inode(struct m_inode * inode);
|
||||
|
||||
static inline void wait_on_inode(struct m_inode * inode)
|
||||
{
|
||||
cli();
|
||||
while (inode->i_lock)
|
||||
sleep_on(&inode->i_wait);
|
||||
sti();
|
||||
}
|
||||
|
||||
static inline void lock_inode(struct m_inode * inode)
|
||||
{
|
||||
cli();
|
||||
while (inode->i_lock)
|
||||
sleep_on(&inode->i_wait);
|
||||
inode->i_lock=1;
|
||||
sti();
|
||||
}
|
||||
|
||||
static inline void unlock_inode(struct m_inode * inode)
|
||||
{
|
||||
inode->i_lock=0;
|
||||
wake_up(&inode->i_wait);
|
||||
}
|
||||
|
||||
void invalidate_inodes(int dev)
|
||||
{
|
||||
int i;
|
||||
struct m_inode * inode;
|
||||
|
||||
inode = 0+inode_table;
|
||||
for(i=0 ; i<NR_INODE ; i++,inode++) {
|
||||
wait_on_inode(inode);
|
||||
if (inode->i_dev == dev) {
|
||||
if (inode->i_count)
|
||||
printk("inode in use on removed disk\n\r");
|
||||
inode->i_dev = inode->i_dirt = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void sync_inodes(void)
|
||||
{
|
||||
int i;
|
||||
struct m_inode * inode;
|
||||
|
||||
inode = 0+inode_table;
|
||||
for(i=0 ; i<NR_INODE ; i++,inode++) {
|
||||
wait_on_inode(inode);
|
||||
if (inode->i_dirt && !inode->i_pipe)
|
||||
write_inode(inode);
|
||||
}
|
||||
}
|
||||
|
||||
static int _bmap(struct m_inode * inode,int block,int create)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
int i;
|
||||
|
||||
if (block<0)
|
||||
panic("_bmap: block<0");
|
||||
if (block >= 7+512+512*512)
|
||||
panic("_bmap: block>big");
|
||||
if (block<7) {
|
||||
if (create && !inode->i_zone[block])
|
||||
if (inode->i_zone[block]=new_block(inode->i_dev)) {
|
||||
inode->i_ctime=CURRENT_TIME;
|
||||
inode->i_dirt=1;
|
||||
}
|
||||
return inode->i_zone[block];
|
||||
}
|
||||
block -= 7;
|
||||
if (block<512) {
|
||||
if (create && !inode->i_zone[7])
|
||||
if (inode->i_zone[7]=new_block(inode->i_dev)) {
|
||||
inode->i_dirt=1;
|
||||
inode->i_ctime=CURRENT_TIME;
|
||||
}
|
||||
if (!inode->i_zone[7])
|
||||
return 0;
|
||||
if (!(bh = bread(inode->i_dev,inode->i_zone[7])))
|
||||
return 0;
|
||||
i = ((unsigned short *) (bh->b_data))[block];
|
||||
if (create && !i)
|
||||
if (i=new_block(inode->i_dev)) {
|
||||
((unsigned short *) (bh->b_data))[block]=i;
|
||||
bh->b_dirt=1;
|
||||
}
|
||||
brelse(bh);
|
||||
return i;
|
||||
}
|
||||
block -= 512;
|
||||
if (create && !inode->i_zone[8])
|
||||
if (inode->i_zone[8]=new_block(inode->i_dev)) {
|
||||
inode->i_dirt=1;
|
||||
inode->i_ctime=CURRENT_TIME;
|
||||
}
|
||||
if (!inode->i_zone[8])
|
||||
return 0;
|
||||
if (!(bh=bread(inode->i_dev,inode->i_zone[8])))
|
||||
return 0;
|
||||
i = ((unsigned short *)bh->b_data)[block>>9];
|
||||
if (create && !i)
|
||||
if (i=new_block(inode->i_dev)) {
|
||||
((unsigned short *) (bh->b_data))[block>>9]=i;
|
||||
bh->b_dirt=1;
|
||||
}
|
||||
brelse(bh);
|
||||
if (!i)
|
||||
return 0;
|
||||
if (!(bh=bread(inode->i_dev,i)))
|
||||
return 0;
|
||||
i = ((unsigned short *)bh->b_data)[block&511];
|
||||
if (create && !i)
|
||||
if (i=new_block(inode->i_dev)) {
|
||||
((unsigned short *) (bh->b_data))[block&511]=i;
|
||||
bh->b_dirt=1;
|
||||
}
|
||||
brelse(bh);
|
||||
return i;
|
||||
}
|
||||
|
||||
int bmap(struct m_inode * inode,int block)
|
||||
{
|
||||
return _bmap(inode,block,0);
|
||||
}
|
||||
|
||||
int create_block(struct m_inode * inode, int block)
|
||||
{
|
||||
return _bmap(inode,block,1);
|
||||
}
|
||||
|
||||
void iput(struct m_inode * inode)
|
||||
{
|
||||
if (!inode)
|
||||
return;
|
||||
wait_on_inode(inode);
|
||||
if (!inode->i_count)
|
||||
panic("iput: trying to free free inode");
|
||||
if (inode->i_pipe) {
|
||||
wake_up(&inode->i_wait);
|
||||
if (--inode->i_count)
|
||||
return;
|
||||
free_page(inode->i_size);
|
||||
inode->i_count=0;
|
||||
inode->i_dirt=0;
|
||||
inode->i_pipe=0;
|
||||
return;
|
||||
}
|
||||
if (!inode->i_dev) {
|
||||
inode->i_count--;
|
||||
return;
|
||||
}
|
||||
if (S_ISBLK(inode->i_mode)) {
|
||||
sync_dev(inode->i_zone[0]);
|
||||
wait_on_inode(inode);
|
||||
}
|
||||
repeat:
|
||||
if (inode->i_count>1) {
|
||||
inode->i_count--;
|
||||
return;
|
||||
}
|
||||
if (!inode->i_nlinks) {
|
||||
truncate(inode);
|
||||
free_inode(inode);
|
||||
return;
|
||||
}
|
||||
if (inode->i_dirt) {
|
||||
write_inode(inode); /* we can sleep - so do again */
|
||||
wait_on_inode(inode);
|
||||
goto repeat;
|
||||
}
|
||||
inode->i_count--;
|
||||
return;
|
||||
}
|
||||
|
||||
struct m_inode * get_empty_inode(void)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
static struct m_inode * last_inode = inode_table;
|
||||
int i;
|
||||
|
||||
do {
|
||||
inode = NULL;
|
||||
for (i = NR_INODE; i ; i--) {
|
||||
if (++last_inode >= inode_table + NR_INODE)
|
||||
last_inode = inode_table;
|
||||
if (!last_inode->i_count) {
|
||||
inode = last_inode;
|
||||
if (!inode->i_dirt && !inode->i_lock)
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!inode) {
|
||||
for (i=0 ; i<NR_INODE ; i++)
|
||||
printk("%04x: %6d\t",inode_table[i].i_dev,
|
||||
inode_table[i].i_num);
|
||||
panic("No free inodes in mem");
|
||||
}
|
||||
wait_on_inode(inode);
|
||||
while (inode->i_dirt) {
|
||||
write_inode(inode);
|
||||
wait_on_inode(inode);
|
||||
}
|
||||
} while (inode->i_count);
|
||||
memset(inode,0,sizeof(*inode));
|
||||
inode->i_count = 1;
|
||||
return inode;
|
||||
}
|
||||
|
||||
struct m_inode * get_pipe_inode(void)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
|
||||
if (!(inode = get_empty_inode()))
|
||||
return NULL;
|
||||
if (!(inode->i_size=get_free_page())) {
|
||||
inode->i_count = 0;
|
||||
return NULL;
|
||||
}
|
||||
inode->i_count = 2; /* sum of readers/writers */
|
||||
PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
|
||||
inode->i_pipe = 1;
|
||||
return inode;
|
||||
}
|
||||
|
||||
struct m_inode * iget(int dev,int nr)
|
||||
{
|
||||
struct m_inode * inode, * empty;
|
||||
|
||||
if (!dev)
|
||||
panic("iget with dev==0");
|
||||
empty = get_empty_inode();
|
||||
inode = inode_table;
|
||||
while (inode < NR_INODE+inode_table) {
|
||||
if (inode->i_dev != dev || inode->i_num != nr) {
|
||||
inode++;
|
||||
continue;
|
||||
}
|
||||
wait_on_inode(inode);
|
||||
if (inode->i_dev != dev || inode->i_num != nr) {
|
||||
inode = inode_table;
|
||||
continue;
|
||||
}
|
||||
inode->i_count++;
|
||||
if (inode->i_mount) {
|
||||
int i;
|
||||
|
||||
for (i = 0 ; i<NR_SUPER ; i++)
|
||||
if (super_block[i].s_imount==inode)
|
||||
break;
|
||||
if (i >= NR_SUPER) {
|
||||
printk("Mounted inode hasn't got sb\n");
|
||||
if (empty)
|
||||
iput(empty);
|
||||
return inode;
|
||||
}
|
||||
iput(inode);
|
||||
dev = super_block[i].s_dev;
|
||||
nr = ROOT_INO;
|
||||
inode = inode_table;
|
||||
continue;
|
||||
}
|
||||
if (empty)
|
||||
iput(empty);
|
||||
return inode;
|
||||
}
|
||||
if (!empty)
|
||||
return (NULL);
|
||||
inode=empty;
|
||||
inode->i_dev = dev;
|
||||
inode->i_num = nr;
|
||||
read_inode(inode);
|
||||
return inode;
|
||||
}
|
||||
|
||||
static void read_inode(struct m_inode * inode)
|
||||
{
|
||||
struct super_block * sb;
|
||||
struct buffer_head * bh;
|
||||
int block;
|
||||
|
||||
lock_inode(inode);
|
||||
if (!(sb=get_super(inode->i_dev)))
|
||||
panic("trying to read inode without dev");
|
||||
block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
|
||||
(inode->i_num-1)/INODES_PER_BLOCK;
|
||||
if (!(bh=bread(inode->i_dev,block)))
|
||||
panic("unable to read i-node block");
|
||||
__asm__ volatile ("cld"); /* by wyj */
|
||||
*(struct d_inode *)inode =
|
||||
((struct d_inode *)bh->b_data)
|
||||
[(inode->i_num-1)%INODES_PER_BLOCK];
|
||||
brelse(bh);
|
||||
unlock_inode(inode);
|
||||
}
|
||||
|
||||
static void write_inode(struct m_inode * inode)
|
||||
{
|
||||
struct super_block * sb;
|
||||
struct buffer_head * bh;
|
||||
int block;
|
||||
|
||||
lock_inode(inode);
|
||||
if (!inode->i_dirt || !inode->i_dev) {
|
||||
unlock_inode(inode);
|
||||
return;
|
||||
}
|
||||
if (!(sb=get_super(inode->i_dev)))
|
||||
panic("trying to write inode without device");
|
||||
block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
|
||||
(inode->i_num-1)/INODES_PER_BLOCK;
|
||||
if (!(bh=bread(inode->i_dev,block)))
|
||||
panic("unable to read i-node block");
|
||||
__asm__ volatile ("cld"); /* by wyj */
|
||||
((struct d_inode *)bh->b_data)
|
||||
[(inode->i_num-1)%INODES_PER_BLOCK] =
|
||||
*(struct d_inode *)inode;
|
||||
bh->b_dirt=1;
|
||||
inode->i_dirt=0;
|
||||
brelse(bh);
|
||||
unlock_inode(inode);
|
||||
}
|
||||
Binary file not shown.
@ -1,46 +0,0 @@
|
||||
/*
|
||||
* linux/fs/ioctl.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
|
||||
extern int tty_ioctl(int dev, int cmd, int arg);
|
||||
|
||||
typedef int (*ioctl_ptr)(int dev,int cmd,int arg);
|
||||
|
||||
#define NRDEVS ((sizeof (ioctl_table))/(sizeof (ioctl_ptr)))
|
||||
|
||||
static ioctl_ptr ioctl_table[]={
|
||||
NULL, /* nodev */
|
||||
NULL, /* /dev/mem */
|
||||
NULL, /* /dev/fd */
|
||||
NULL, /* /dev/hd */
|
||||
tty_ioctl, /* /dev/ttyx */
|
||||
tty_ioctl, /* /dev/tty */
|
||||
NULL, /* /dev/lp */
|
||||
NULL}; /* named pipes */
|
||||
|
||||
|
||||
int sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct file * filp;
|
||||
int dev,mode;
|
||||
|
||||
if (fd >= NR_OPEN || !(filp = current->filp[fd]))
|
||||
return -EBADF;
|
||||
mode=filp->f_inode->i_mode;
|
||||
if (!S_ISCHR(mode) && !S_ISBLK(mode))
|
||||
return -EINVAL;
|
||||
dev = filp->f_inode->i_zone[0];
|
||||
if (MAJOR(dev) >= NRDEVS)
|
||||
return -ENODEV;
|
||||
if (!ioctl_table[MAJOR(dev)])
|
||||
return -ENOTTY;
|
||||
return ioctl_table[MAJOR(dev)](dev,cmd,arg);
|
||||
}
|
||||
Binary file not shown.
@ -1,783 +0,0 @@
|
||||
/*
|
||||
* linux/fs/namei.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* Some corrections by tytso.
|
||||
*/
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <const.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#define ACC_MODE(x) ("\004\002\006\377"[(x)&O_ACCMODE])
|
||||
|
||||
/*
|
||||
* comment out this line if you want names > NAME_LEN chars to be
|
||||
* truncated. Else they will be disallowed.
|
||||
*/
|
||||
/* #define NO_TRUNCATE */
|
||||
|
||||
#define MAY_EXEC 1
|
||||
#define MAY_WRITE 2
|
||||
#define MAY_READ 4
|
||||
|
||||
/*
|
||||
* permission()
|
||||
*
|
||||
* is used to check for read/write/execute permissions on a file.
|
||||
* I don't know if we should look at just the euid or both euid and
|
||||
* uid, but that should be easily changed.
|
||||
*/
|
||||
static int permission(struct m_inode * inode,int mask)
|
||||
{
|
||||
int mode = inode->i_mode;
|
||||
|
||||
/* special case: not even root can read/write a deleted file */
|
||||
if (inode->i_dev && !inode->i_nlinks)
|
||||
return 0;
|
||||
else if (current->euid==inode->i_uid)
|
||||
mode >>= 6;
|
||||
else if (current->egid==inode->i_gid)
|
||||
mode >>= 3;
|
||||
if (((mode & mask & 0007) == mask) || suser())
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* ok, we cannot use strncmp, as the name is not in our data space.
|
||||
* Thus we'll have to use match. No big problem. Match also makes
|
||||
* some sanity tests.
|
||||
*
|
||||
* NOTE! unlike strncmp, match returns 1 for success, 0 for failure.
|
||||
*/
|
||||
static int match(int len,const char * name,struct dir_entry * de)
|
||||
{
|
||||
register int same __asm__("ax");
|
||||
|
||||
if (!de || !de->inode || len > NAME_LEN)
|
||||
return 0;
|
||||
if (len < NAME_LEN && de->name[len])
|
||||
return 0;
|
||||
__asm__("cld\n\t"
|
||||
"fs ; repe ; cmpsb\n\t"
|
||||
"setz %%al"
|
||||
:"=a" (same)
|
||||
:"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len)
|
||||
);
|
||||
return same;
|
||||
}
|
||||
|
||||
/*
|
||||
* find_entry()
|
||||
*
|
||||
* finds an entry in the specified directory with the wanted name. It
|
||||
* returns the cache buffer in which the entry was found, and the entry
|
||||
* itself (as a parameter - res_dir). It does NOT read the inode of the
|
||||
* entry - you'll have to do that yourself if you want to.
|
||||
*
|
||||
* This also takes care of the few special cases due to '..'-traversal
|
||||
* over a pseudo-root and a mount point.
|
||||
*/
|
||||
static struct buffer_head * find_entry(struct m_inode ** dir,
|
||||
const char * name, int namelen, struct dir_entry ** res_dir)
|
||||
{
|
||||
int entries;
|
||||
int block,i;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
struct super_block * sb;
|
||||
|
||||
#ifdef NO_TRUNCATE
|
||||
if (namelen > NAME_LEN)
|
||||
return NULL;
|
||||
#else
|
||||
if (namelen > NAME_LEN)
|
||||
namelen = NAME_LEN;
|
||||
#endif
|
||||
entries = (*dir)->i_size / (sizeof (struct dir_entry));
|
||||
*res_dir = NULL;
|
||||
if (!namelen)
|
||||
return NULL;
|
||||
/* check for '..', as we might have to do some "magic" for it */
|
||||
if (namelen==2 && get_fs_byte(name)=='.' && get_fs_byte(name+1)=='.') {
|
||||
/* '..' in a pseudo-root results in a faked '.' (just change namelen) */
|
||||
if ((*dir) == current->root)
|
||||
namelen=1;
|
||||
else if ((*dir)->i_num == ROOT_INO) {
|
||||
/* '..' over a mount-point results in 'dir' being exchanged for the mounted
|
||||
directory-inode. NOTE! We set mounted, so that we can iput the new dir */
|
||||
sb=get_super((*dir)->i_dev);
|
||||
if (sb->s_imount) {
|
||||
iput(*dir);
|
||||
(*dir)=sb->s_imount;
|
||||
(*dir)->i_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!(block = (*dir)->i_zone[0]))
|
||||
return NULL;
|
||||
if (!(bh = bread((*dir)->i_dev,block)))
|
||||
return NULL;
|
||||
i = 0;
|
||||
de = (struct dir_entry *) bh->b_data;
|
||||
while (i < entries) {
|
||||
if ((char *)de >= BLOCK_SIZE+bh->b_data) {
|
||||
brelse(bh);
|
||||
bh = NULL;
|
||||
if (!(block = bmap(*dir,i/DIR_ENTRIES_PER_BLOCK)) ||
|
||||
!(bh = bread((*dir)->i_dev,block))) {
|
||||
i += DIR_ENTRIES_PER_BLOCK;
|
||||
continue;
|
||||
}
|
||||
de = (struct dir_entry *) bh->b_data;
|
||||
}
|
||||
if (match(namelen,name,de)) {
|
||||
*res_dir = de;
|
||||
return bh;
|
||||
}
|
||||
de++;
|
||||
i++;
|
||||
}
|
||||
brelse(bh);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* add_entry()
|
||||
*
|
||||
* adds a file entry to the specified directory, using the same
|
||||
* semantics as find_entry(). It returns NULL if it failed.
|
||||
*
|
||||
* NOTE!! The inode part of 'de' is left at 0 - which means you
|
||||
* may not sleep between calling this and putting something into
|
||||
* the entry, as someone else might have used it while you slept.
|
||||
*/
|
||||
static struct buffer_head * add_entry(struct m_inode * dir,
|
||||
const char * name, int namelen, struct dir_entry ** res_dir)
|
||||
{
|
||||
int block,i;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
*res_dir = NULL;
|
||||
#ifdef NO_TRUNCATE
|
||||
if (namelen > NAME_LEN)
|
||||
return NULL;
|
||||
#else
|
||||
if (namelen > NAME_LEN)
|
||||
namelen = NAME_LEN;
|
||||
#endif
|
||||
if (!namelen)
|
||||
return NULL;
|
||||
if (!(block = dir->i_zone[0]))
|
||||
return NULL;
|
||||
if (!(bh = bread(dir->i_dev,block)))
|
||||
return NULL;
|
||||
i = 0;
|
||||
de = (struct dir_entry *) bh->b_data;
|
||||
while (1) {
|
||||
if ((char *)de >= BLOCK_SIZE+bh->b_data) {
|
||||
brelse(bh);
|
||||
bh = NULL;
|
||||
block = create_block(dir,i/DIR_ENTRIES_PER_BLOCK);
|
||||
if (!block)
|
||||
return NULL;
|
||||
if (!(bh = bread(dir->i_dev,block))) {
|
||||
i += DIR_ENTRIES_PER_BLOCK;
|
||||
continue;
|
||||
}
|
||||
de = (struct dir_entry *) bh->b_data;
|
||||
}
|
||||
if (i*sizeof(struct dir_entry) >= dir->i_size) {
|
||||
de->inode=0;
|
||||
dir->i_size = (i+1)*sizeof(struct dir_entry);
|
||||
dir->i_dirt = 1;
|
||||
dir->i_ctime = CURRENT_TIME;
|
||||
}
|
||||
if (!de->inode) {
|
||||
dir->i_mtime = CURRENT_TIME;
|
||||
for (i=0; i < NAME_LEN ; i++)
|
||||
de->name[i]=(i<namelen)?get_fs_byte(name+i):0;
|
||||
bh->b_dirt = 1;
|
||||
*res_dir = de;
|
||||
return bh;
|
||||
}
|
||||
de++;
|
||||
i++;
|
||||
}
|
||||
brelse(bh);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* get_dir()
|
||||
*
|
||||
* Getdir traverses the pathname until it hits the topmost directory.
|
||||
* It returns NULL on failure.
|
||||
*/
|
||||
static struct m_inode * get_dir(const char * pathname)
|
||||
{
|
||||
char c;
|
||||
const char * thisname;
|
||||
struct m_inode * inode;
|
||||
struct buffer_head * bh;
|
||||
int namelen,inr,idev;
|
||||
struct dir_entry * de;
|
||||
|
||||
if (!current->root || !current->root->i_count)
|
||||
panic("No root inode");
|
||||
if (!current->pwd || !current->pwd->i_count)
|
||||
panic("No cwd inode");
|
||||
if ((c=get_fs_byte(pathname))=='/') {
|
||||
inode = current->root;
|
||||
pathname++;
|
||||
} else if (c)
|
||||
inode = current->pwd;
|
||||
else
|
||||
return NULL; /* empty name is bad */
|
||||
inode->i_count++;
|
||||
while (1) {
|
||||
thisname = pathname;
|
||||
if (!S_ISDIR(inode->i_mode) || !permission(inode,MAY_EXEC)) {
|
||||
iput(inode);
|
||||
return NULL;
|
||||
}
|
||||
for(namelen=0;(c=get_fs_byte(pathname++))&&(c!='/');namelen++)
|
||||
/* nothing */ ;
|
||||
if (!c)
|
||||
return inode;
|
||||
if (!(bh = find_entry(&inode,thisname,namelen,&de))) {
|
||||
iput(inode);
|
||||
return NULL;
|
||||
}
|
||||
inr = de->inode;
|
||||
idev = inode->i_dev;
|
||||
brelse(bh);
|
||||
iput(inode);
|
||||
if (!(inode = iget(idev,inr)))
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* dir_namei()
|
||||
*
|
||||
* dir_namei() returns the inode of the directory of the
|
||||
* specified name, and the name within that directory.
|
||||
*/
|
||||
static struct m_inode * dir_namei(const char * pathname,
|
||||
int * namelen, const char ** name)
|
||||
{
|
||||
char c;
|
||||
const char * basename;
|
||||
struct m_inode * dir;
|
||||
|
||||
if (!(dir = get_dir(pathname)))
|
||||
return NULL;
|
||||
basename = pathname;
|
||||
while (c=get_fs_byte(pathname++))
|
||||
if (c=='/')
|
||||
basename=pathname;
|
||||
*namelen = pathname-basename-1;
|
||||
*name = basename;
|
||||
return dir;
|
||||
}
|
||||
|
||||
/*
|
||||
* namei()
|
||||
*
|
||||
* is used by most simple commands to get the inode of a specified name.
|
||||
* Open, link etc use their own routines, but this is enough for things
|
||||
* like 'chmod' etc.
|
||||
*/
|
||||
struct m_inode * namei(const char * pathname)
|
||||
{
|
||||
const char * basename;
|
||||
int inr,dev,namelen;
|
||||
struct m_inode * dir;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
if (!(dir = dir_namei(pathname,&namelen,&basename)))
|
||||
return NULL;
|
||||
if (!namelen) /* special case: '/usr/' etc */
|
||||
return dir;
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
iput(dir);
|
||||
return NULL;
|
||||
}
|
||||
inr = de->inode;
|
||||
dev = dir->i_dev;
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
dir=iget(dev,inr);
|
||||
if (dir) {
|
||||
dir->i_atime=CURRENT_TIME;
|
||||
dir->i_dirt=1;
|
||||
}
|
||||
return dir;
|
||||
}
|
||||
|
||||
/*
|
||||
* open_namei()
|
||||
*
|
||||
* namei for open - this is in fact almost the whole open-routine.
|
||||
*/
|
||||
int open_namei(const char * pathname, int flag, int mode,
|
||||
struct m_inode ** res_inode)
|
||||
{
|
||||
const char * basename;
|
||||
int inr,dev,namelen;
|
||||
struct m_inode * dir, *inode;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
if ((flag & O_TRUNC) && !(flag & O_ACCMODE))
|
||||
flag |= O_WRONLY;
|
||||
mode &= 0777 & ~current->umask;
|
||||
mode |= I_REGULAR;
|
||||
if (!(dir = dir_namei(pathname,&namelen,&basename)))
|
||||
return -ENOENT;
|
||||
if (!namelen) { /* special case: '/usr/' etc */
|
||||
if (!(flag & (O_ACCMODE|O_CREAT|O_TRUNC))) {
|
||||
*res_inode=dir;
|
||||
return 0;
|
||||
}
|
||||
iput(dir);
|
||||
return -EISDIR;
|
||||
}
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
if (!(flag & O_CREAT)) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!permission(dir,MAY_WRITE)) {
|
||||
iput(dir);
|
||||
return -EACCES;
|
||||
}
|
||||
inode = new_inode(dir->i_dev);
|
||||
if (!inode) {
|
||||
iput(dir);
|
||||
return -ENOSPC;
|
||||
}
|
||||
inode->i_uid = current->euid;
|
||||
inode->i_mode = mode;
|
||||
inode->i_dirt = 1;
|
||||
bh = add_entry(dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
inode->i_nlinks--;
|
||||
iput(inode);
|
||||
iput(dir);
|
||||
return -ENOSPC;
|
||||
}
|
||||
de->inode = inode->i_num;
|
||||
bh->b_dirt = 1;
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
*res_inode = inode;
|
||||
return 0;
|
||||
}
|
||||
inr = de->inode;
|
||||
dev = dir->i_dev;
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
if (flag & O_EXCL)
|
||||
return -EEXIST;
|
||||
if (!(inode=iget(dev,inr)))
|
||||
return -EACCES;
|
||||
if ((S_ISDIR(inode->i_mode) && (flag & O_ACCMODE)) ||
|
||||
!permission(inode,ACC_MODE(flag))) {
|
||||
iput(inode);
|
||||
return -EPERM;
|
||||
}
|
||||
inode->i_atime = CURRENT_TIME;
|
||||
if (flag & O_TRUNC)
|
||||
truncate(inode);
|
||||
*res_inode = inode;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_mknod(const char * filename, int mode, int dev)
|
||||
{
|
||||
const char * basename;
|
||||
int namelen;
|
||||
struct m_inode * dir, * inode;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
if (!suser())
|
||||
return -EPERM;
|
||||
if (!(dir = dir_namei(filename,&namelen,&basename)))
|
||||
return -ENOENT;
|
||||
if (!namelen) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!permission(dir,MAY_WRITE)) {
|
||||
iput(dir);
|
||||
return -EPERM;
|
||||
}
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (bh) {
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
return -EEXIST;
|
||||
}
|
||||
inode = new_inode(dir->i_dev);
|
||||
if (!inode) {
|
||||
iput(dir);
|
||||
return -ENOSPC;
|
||||
}
|
||||
inode->i_mode = mode;
|
||||
if (S_ISBLK(mode) || S_ISCHR(mode))
|
||||
inode->i_zone[0] = dev;
|
||||
inode->i_mtime = inode->i_atime = CURRENT_TIME;
|
||||
inode->i_dirt = 1;
|
||||
bh = add_entry(dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
iput(dir);
|
||||
inode->i_nlinks=0;
|
||||
iput(inode);
|
||||
return -ENOSPC;
|
||||
}
|
||||
de->inode = inode->i_num;
|
||||
bh->b_dirt = 1;
|
||||
iput(dir);
|
||||
iput(inode);
|
||||
brelse(bh);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_mkdir(const char * pathname, int mode)
|
||||
{
|
||||
const char * basename;
|
||||
int namelen;
|
||||
struct m_inode * dir, * inode;
|
||||
struct buffer_head * bh, *dir_block;
|
||||
struct dir_entry * de;
|
||||
|
||||
if (!suser())
|
||||
return -EPERM;
|
||||
if (!(dir = dir_namei(pathname,&namelen,&basename)))
|
||||
return -ENOENT;
|
||||
if (!namelen) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!permission(dir,MAY_WRITE)) {
|
||||
iput(dir);
|
||||
return -EPERM;
|
||||
}
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (bh) {
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
return -EEXIST;
|
||||
}
|
||||
inode = new_inode(dir->i_dev);
|
||||
if (!inode) {
|
||||
iput(dir);
|
||||
return -ENOSPC;
|
||||
}
|
||||
inode->i_size = 32;
|
||||
inode->i_dirt = 1;
|
||||
inode->i_mtime = inode->i_atime = CURRENT_TIME;
|
||||
if (!(inode->i_zone[0]=new_block(inode->i_dev))) {
|
||||
iput(dir);
|
||||
inode->i_nlinks--;
|
||||
iput(inode);
|
||||
return -ENOSPC;
|
||||
}
|
||||
inode->i_dirt = 1;
|
||||
if (!(dir_block=bread(inode->i_dev,inode->i_zone[0]))) {
|
||||
iput(dir);
|
||||
free_block(inode->i_dev,inode->i_zone[0]);
|
||||
inode->i_nlinks--;
|
||||
iput(inode);
|
||||
return -ERROR;
|
||||
}
|
||||
de = (struct dir_entry *) dir_block->b_data;
|
||||
de->inode=inode->i_num;
|
||||
strcpy(de->name,".");
|
||||
de++;
|
||||
de->inode = dir->i_num;
|
||||
strcpy(de->name,"..");
|
||||
inode->i_nlinks = 2;
|
||||
dir_block->b_dirt = 1;
|
||||
brelse(dir_block);
|
||||
inode->i_mode = I_DIRECTORY | (mode & 0777 & ~current->umask);
|
||||
inode->i_dirt = 1;
|
||||
bh = add_entry(dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
iput(dir);
|
||||
free_block(inode->i_dev,inode->i_zone[0]);
|
||||
inode->i_nlinks=0;
|
||||
iput(inode);
|
||||
return -ENOSPC;
|
||||
}
|
||||
de->inode = inode->i_num;
|
||||
bh->b_dirt = 1;
|
||||
dir->i_nlinks++;
|
||||
dir->i_dirt = 1;
|
||||
iput(dir);
|
||||
iput(inode);
|
||||
brelse(bh);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* routine to check that the specified directory is empty (for rmdir)
|
||||
*/
|
||||
static int empty_dir(struct m_inode * inode)
|
||||
{
|
||||
int nr,block;
|
||||
int len;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
len = inode->i_size / sizeof (struct dir_entry);
|
||||
if (len<2 || !inode->i_zone[0] ||
|
||||
!(bh=bread(inode->i_dev,inode->i_zone[0]))) {
|
||||
printk("warning - bad directory on dev %04x\n",inode->i_dev);
|
||||
return 0;
|
||||
}
|
||||
de = (struct dir_entry *) bh->b_data;
|
||||
if (de[0].inode != inode->i_num || !de[1].inode ||
|
||||
strcmp(".",de[0].name) || strcmp("..",de[1].name)) {
|
||||
printk("warning - bad directory on dev %04x\n",inode->i_dev);
|
||||
return 0;
|
||||
}
|
||||
nr = 2;
|
||||
de += 2;
|
||||
while (nr<len) {
|
||||
if ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) {
|
||||
brelse(bh);
|
||||
block=bmap(inode,nr/DIR_ENTRIES_PER_BLOCK);
|
||||
if (!block) {
|
||||
nr += DIR_ENTRIES_PER_BLOCK;
|
||||
continue;
|
||||
}
|
||||
if (!(bh=bread(inode->i_dev,block)))
|
||||
return 0;
|
||||
de = (struct dir_entry *) bh->b_data;
|
||||
}
|
||||
if (de->inode) {
|
||||
brelse(bh);
|
||||
return 0;
|
||||
}
|
||||
de++;
|
||||
nr++;
|
||||
}
|
||||
brelse(bh);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int sys_rmdir(const char * name)
|
||||
{
|
||||
const char * basename;
|
||||
int namelen;
|
||||
struct m_inode * dir, * inode;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
if (!suser())
|
||||
return -EPERM;
|
||||
if (!(dir = dir_namei(name,&namelen,&basename)))
|
||||
return -ENOENT;
|
||||
if (!namelen) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!permission(dir,MAY_WRITE)) {
|
||||
iput(dir);
|
||||
return -EPERM;
|
||||
}
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!(inode = iget(dir->i_dev, de->inode))) {
|
||||
iput(dir);
|
||||
brelse(bh);
|
||||
return -EPERM;
|
||||
}
|
||||
if ((dir->i_mode & S_ISVTX) && current->euid &&
|
||||
inode->i_uid != current->euid) {
|
||||
iput(dir);
|
||||
iput(inode);
|
||||
brelse(bh);
|
||||
return -EPERM;
|
||||
}
|
||||
if (inode->i_dev != dir->i_dev || inode->i_count>1) {
|
||||
iput(dir);
|
||||
iput(inode);
|
||||
brelse(bh);
|
||||
return -EPERM;
|
||||
}
|
||||
if (inode == dir) { /* we may not delete ".", but "../dir" is ok */
|
||||
iput(inode);
|
||||
iput(dir);
|
||||
brelse(bh);
|
||||
return -EPERM;
|
||||
}
|
||||
if (!S_ISDIR(inode->i_mode)) {
|
||||
iput(inode);
|
||||
iput(dir);
|
||||
brelse(bh);
|
||||
return -ENOTDIR;
|
||||
}
|
||||
if (!empty_dir(inode)) {
|
||||
iput(inode);
|
||||
iput(dir);
|
||||
brelse(bh);
|
||||
return -ENOTEMPTY;
|
||||
}
|
||||
if (inode->i_nlinks != 2)
|
||||
printk("empty directory has nlink!=2 (%d)",inode->i_nlinks);
|
||||
de->inode = 0;
|
||||
bh->b_dirt = 1;
|
||||
brelse(bh);
|
||||
inode->i_nlinks=0;
|
||||
inode->i_dirt=1;
|
||||
dir->i_nlinks--;
|
||||
dir->i_ctime = dir->i_mtime = CURRENT_TIME;
|
||||
dir->i_dirt=1;
|
||||
iput(dir);
|
||||
iput(inode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_unlink(const char * name)
|
||||
{
|
||||
const char * basename;
|
||||
int namelen;
|
||||
struct m_inode * dir, * inode;
|
||||
struct buffer_head * bh;
|
||||
struct dir_entry * de;
|
||||
|
||||
if (!(dir = dir_namei(name,&namelen,&basename)))
|
||||
return -ENOENT;
|
||||
if (!namelen) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!permission(dir,MAY_WRITE)) {
|
||||
iput(dir);
|
||||
return -EPERM;
|
||||
}
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
iput(dir);
|
||||
return -ENOENT;
|
||||
}
|
||||
if (!(inode = iget(dir->i_dev, de->inode))) {
|
||||
iput(dir);
|
||||
brelse(bh);
|
||||
return -ENOENT;
|
||||
}
|
||||
if ((dir->i_mode & S_ISVTX) && !suser() &&
|
||||
current->euid != inode->i_uid &&
|
||||
current->euid != dir->i_uid) {
|
||||
iput(dir);
|
||||
iput(inode);
|
||||
brelse(bh);
|
||||
return -EPERM;
|
||||
}
|
||||
if (S_ISDIR(inode->i_mode)) {
|
||||
iput(inode);
|
||||
iput(dir);
|
||||
brelse(bh);
|
||||
return -EPERM;
|
||||
}
|
||||
if (!inode->i_nlinks) {
|
||||
printk("Deleting nonexistent file (%04x:%d), %d\n",
|
||||
inode->i_dev,inode->i_num,inode->i_nlinks);
|
||||
inode->i_nlinks=1;
|
||||
}
|
||||
de->inode = 0;
|
||||
bh->b_dirt = 1;
|
||||
brelse(bh);
|
||||
inode->i_nlinks--;
|
||||
inode->i_dirt = 1;
|
||||
inode->i_ctime = CURRENT_TIME;
|
||||
iput(inode);
|
||||
iput(dir);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_symlink()
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
int sys_link(const char * oldname, const char * newname)
|
||||
{
|
||||
struct dir_entry * de;
|
||||
struct m_inode * oldinode, * dir;
|
||||
struct buffer_head * bh;
|
||||
const char * basename;
|
||||
int namelen;
|
||||
|
||||
oldinode=namei(oldname);
|
||||
if (!oldinode)
|
||||
return -ENOENT;
|
||||
if (S_ISDIR(oldinode->i_mode)) {
|
||||
iput(oldinode);
|
||||
return -EPERM;
|
||||
}
|
||||
dir = dir_namei(newname,&namelen,&basename);
|
||||
if (!dir) {
|
||||
iput(oldinode);
|
||||
return -EACCES;
|
||||
}
|
||||
if (!namelen) {
|
||||
iput(oldinode);
|
||||
iput(dir);
|
||||
return -EPERM;
|
||||
}
|
||||
if (dir->i_dev != oldinode->i_dev) {
|
||||
iput(dir);
|
||||
iput(oldinode);
|
||||
return -EXDEV;
|
||||
}
|
||||
if (!permission(dir,MAY_WRITE)) {
|
||||
iput(dir);
|
||||
iput(oldinode);
|
||||
return -EACCES;
|
||||
}
|
||||
bh = find_entry(&dir,basename,namelen,&de);
|
||||
if (bh) {
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
iput(oldinode);
|
||||
return -EEXIST;
|
||||
}
|
||||
bh = add_entry(dir,basename,namelen,&de);
|
||||
if (!bh) {
|
||||
iput(dir);
|
||||
iput(oldinode);
|
||||
return -ENOSPC;
|
||||
}
|
||||
de->inode = oldinode->i_num;
|
||||
bh->b_dirt = 1;
|
||||
brelse(bh);
|
||||
iput(dir);
|
||||
oldinode->i_nlinks++;
|
||||
oldinode->i_ctime = CURRENT_TIME;
|
||||
oldinode->i_dirt = 1;
|
||||
iput(oldinode);
|
||||
return 0;
|
||||
}
|
||||
Binary file not shown.
@ -1,208 +0,0 @@
|
||||
/*
|
||||
* linux/fs/open.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <utime.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/tty.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
int sys_ustat(int dev, struct ustat * ubuf)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
int sys_utime(char * filename, struct utimbuf * times)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
long actime,modtime;
|
||||
|
||||
if (!(inode=namei(filename)))
|
||||
return -ENOENT;
|
||||
if (times) {
|
||||
actime = get_fs_long((unsigned long *) ×->actime);
|
||||
modtime = get_fs_long((unsigned long *) ×->modtime);
|
||||
} else
|
||||
actime = modtime = CURRENT_TIME;
|
||||
inode->i_atime = actime;
|
||||
inode->i_mtime = modtime;
|
||||
inode->i_dirt = 1;
|
||||
iput(inode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX should we use the real or effective uid? BSD uses the real uid,
|
||||
* so as to make this call useful to setuid programs.
|
||||
*/
|
||||
int sys_access(const char * filename,int mode)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
int res, i_mode;
|
||||
|
||||
mode &= 0007;
|
||||
if (!(inode=namei(filename)))
|
||||
return -EACCES;
|
||||
i_mode = res = inode->i_mode & 0777;
|
||||
iput(inode);
|
||||
if (current->uid == inode->i_uid)
|
||||
res >>= 6;
|
||||
else if (current->gid == inode->i_gid)
|
||||
res >>= 6;
|
||||
if ((res & 0007 & mode) == mode)
|
||||
return 0;
|
||||
/*
|
||||
* XXX we are doing this test last because we really should be
|
||||
* swapping the effective with the real user id (temporarily),
|
||||
* and then calling suser() routine. If we do call the
|
||||
* suser() routine, it needs to be called last.
|
||||
*/
|
||||
if ((!current->uid) &&
|
||||
(!(mode & 1) || (i_mode & 0111)))
|
||||
return 0;
|
||||
return -EACCES;
|
||||
}
|
||||
|
||||
int sys_chdir(const char * filename)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
|
||||
if (!(inode = namei(filename)))
|
||||
return -ENOENT;
|
||||
if (!S_ISDIR(inode->i_mode)) {
|
||||
iput(inode);
|
||||
return -ENOTDIR;
|
||||
}
|
||||
iput(current->pwd);
|
||||
current->pwd = inode;
|
||||
return (0);
|
||||
}
|
||||
|
||||
int sys_chroot(const char * filename)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
|
||||
if (!(inode=namei(filename)))
|
||||
return -ENOENT;
|
||||
if (!S_ISDIR(inode->i_mode)) {
|
||||
iput(inode);
|
||||
return -ENOTDIR;
|
||||
}
|
||||
iput(current->root);
|
||||
current->root = inode;
|
||||
return (0);
|
||||
}
|
||||
|
||||
int sys_chmod(const char * filename,int mode)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
|
||||
if (!(inode=namei(filename)))
|
||||
return -ENOENT;
|
||||
if ((current->euid != inode->i_uid) && !suser()) {
|
||||
iput(inode);
|
||||
return -EACCES;
|
||||
}
|
||||
inode->i_mode = (mode & 07777) | (inode->i_mode & ~07777);
|
||||
inode->i_dirt = 1;
|
||||
iput(inode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_chown(const char * filename,int uid,int gid)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
|
||||
if (!(inode=namei(filename)))
|
||||
return -ENOENT;
|
||||
if (!suser()) {
|
||||
iput(inode);
|
||||
return -EACCES;
|
||||
}
|
||||
inode->i_uid=uid;
|
||||
inode->i_gid=gid;
|
||||
inode->i_dirt=1;
|
||||
iput(inode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_open(const char * filename,int flag,int mode)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
struct file * f;
|
||||
int i,fd;
|
||||
|
||||
mode &= 0777 & ~current->umask;
|
||||
for(fd=0 ; fd<NR_OPEN ; fd++)
|
||||
if (!current->filp[fd])
|
||||
break;
|
||||
if (fd>=NR_OPEN)
|
||||
return -EINVAL;
|
||||
current->close_on_exec &= ~(1<<fd);
|
||||
f=0+file_table;
|
||||
for (i=0 ; i<NR_FILE ; i++,f++)
|
||||
if (!f->f_count) break;
|
||||
if (i>=NR_FILE)
|
||||
return -EINVAL;
|
||||
(current->filp[fd]=f)->f_count++;
|
||||
if ((i=open_namei(filename,flag,mode,&inode))<0) {
|
||||
current->filp[fd]=NULL;
|
||||
f->f_count=0;
|
||||
return i;
|
||||
}
|
||||
/* ttys are somewhat special (ttyxx major==4, tty major==5) */
|
||||
if (S_ISCHR(inode->i_mode))
|
||||
if (MAJOR(inode->i_zone[0])==4) {
|
||||
if (current->leader && current->tty<0) {
|
||||
current->tty = MINOR(inode->i_zone[0]);
|
||||
tty_table[current->tty].pgrp = current->pgrp;
|
||||
}
|
||||
} else if (MAJOR(inode->i_zone[0])==5)
|
||||
if (current->tty<0) {
|
||||
iput(inode);
|
||||
current->filp[fd]=NULL;
|
||||
f->f_count=0;
|
||||
return -EPERM;
|
||||
}
|
||||
/* Likewise with block-devices: check for floppy_change */
|
||||
if (S_ISBLK(inode->i_mode))
|
||||
check_disk_change(inode->i_zone[0]);
|
||||
f->f_mode = inode->i_mode;
|
||||
f->f_flags = flag;
|
||||
f->f_count = 1;
|
||||
f->f_inode = inode;
|
||||
f->f_pos = 0;
|
||||
return (fd);
|
||||
}
|
||||
|
||||
int sys_creat(const char * pathname, int mode)
|
||||
{
|
||||
return sys_open(pathname, O_CREAT | O_TRUNC, mode);
|
||||
}
|
||||
|
||||
int sys_close(unsigned int fd)
|
||||
{
|
||||
struct file * filp;
|
||||
|
||||
if (fd >= NR_OPEN)
|
||||
return -EINVAL;
|
||||
current->close_on_exec &= ~(1<<fd);
|
||||
if (!(filp = current->filp[fd]))
|
||||
return -EINVAL;
|
||||
current->filp[fd] = NULL;
|
||||
if (filp->f_count == 0)
|
||||
panic("Close: file count is 0");
|
||||
if (--filp->f_count)
|
||||
return (0);
|
||||
iput(filp->f_inode);
|
||||
return (0);
|
||||
}
|
||||
@ -1,111 +0,0 @@
|
||||
/*
|
||||
* linux/fs/pipe.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/mm.h> /* for get_free_page */
|
||||
#include <asm/segment.h>
|
||||
|
||||
int read_pipe(struct m_inode * inode, char * buf, int count)
|
||||
{
|
||||
int chars, size, read = 0;
|
||||
|
||||
while (count>0) {
|
||||
while (!(size=PIPE_SIZE(*inode))) {
|
||||
wake_up(&inode->i_wait);
|
||||
if (inode->i_count != 2) /* are there any writers? */
|
||||
return read;
|
||||
sleep_on(&inode->i_wait);
|
||||
}
|
||||
chars = PAGE_SIZE-PIPE_TAIL(*inode);
|
||||
if (chars > count)
|
||||
chars = count;
|
||||
if (chars > size)
|
||||
chars = size;
|
||||
count -= chars;
|
||||
read += chars;
|
||||
size = PIPE_TAIL(*inode);
|
||||
PIPE_TAIL(*inode) += chars;
|
||||
PIPE_TAIL(*inode) &= (PAGE_SIZE-1);
|
||||
while (chars-->0)
|
||||
put_fs_byte(((char *)inode->i_size)[size++],buf++);
|
||||
}
|
||||
wake_up(&inode->i_wait);
|
||||
return read;
|
||||
}
|
||||
|
||||
int write_pipe(struct m_inode * inode, char * buf, int count)
|
||||
{
|
||||
int chars, size, written = 0;
|
||||
|
||||
while (count>0) {
|
||||
while (!(size=(PAGE_SIZE-1)-PIPE_SIZE(*inode))) {
|
||||
wake_up(&inode->i_wait);
|
||||
if (inode->i_count != 2) { /* no readers */
|
||||
current->signal |= (1<<(SIGPIPE-1));
|
||||
return written?written:-1;
|
||||
}
|
||||
sleep_on(&inode->i_wait);
|
||||
}
|
||||
chars = PAGE_SIZE-PIPE_HEAD(*inode);
|
||||
if (chars > count)
|
||||
chars = count;
|
||||
if (chars > size)
|
||||
chars = size;
|
||||
count -= chars;
|
||||
written += chars;
|
||||
size = PIPE_HEAD(*inode);
|
||||
PIPE_HEAD(*inode) += chars;
|
||||
PIPE_HEAD(*inode) &= (PAGE_SIZE-1);
|
||||
while (chars-->0)
|
||||
((char *)inode->i_size)[size++]=get_fs_byte(buf++);
|
||||
}
|
||||
wake_up(&inode->i_wait);
|
||||
return written;
|
||||
}
|
||||
|
||||
int sys_pipe(unsigned long * fildes)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
struct file * f[2];
|
||||
int fd[2];
|
||||
int i,j;
|
||||
|
||||
j=0;
|
||||
for(i=0;j<2 && i<NR_FILE;i++)
|
||||
if (!file_table[i].f_count)
|
||||
(f[j++]=i+file_table)->f_count++;
|
||||
if (j==1)
|
||||
f[0]->f_count=0;
|
||||
if (j<2)
|
||||
return -1;
|
||||
j=0;
|
||||
for(i=0;j<2 && i<NR_OPEN;i++)
|
||||
if (!current->filp[i]) {
|
||||
current->filp[ fd[j]=i ] = f[j];
|
||||
j++;
|
||||
}
|
||||
if (j==1)
|
||||
current->filp[fd[0]]=NULL;
|
||||
if (j<2) {
|
||||
f[0]->f_count=f[1]->f_count=0;
|
||||
return -1;
|
||||
}
|
||||
if (!(inode=get_pipe_inode())) {
|
||||
current->filp[fd[0]] =
|
||||
current->filp[fd[1]] = NULL;
|
||||
f[0]->f_count = f[1]->f_count = 0;
|
||||
return -1;
|
||||
}
|
||||
f[0]->f_inode = f[1]->f_inode = inode;
|
||||
f[0]->f_pos = f[1]->f_pos = 0;
|
||||
f[0]->f_mode = 1; /* read */
|
||||
f[1]->f_mode = 2; /* write */
|
||||
put_fs_long(fd[0],0+fildes);
|
||||
put_fs_long(fd[1],1+fildes);
|
||||
return 0;
|
||||
}
|
||||
@ -1,103 +0,0 @@
|
||||
/*
|
||||
* linux/fs/read_write.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <errno.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sched.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
extern int rw_char(int rw,int dev, char * buf, int count, off_t * pos);
|
||||
extern int read_pipe(struct m_inode * inode, char * buf, int count);
|
||||
extern int write_pipe(struct m_inode * inode, char * buf, int count);
|
||||
extern int block_read(int dev, off_t * pos, char * buf, int count);
|
||||
extern int block_write(int dev, off_t * pos, char * buf, int count);
|
||||
extern int file_read(struct m_inode * inode, struct file * filp,
|
||||
char * buf, int count);
|
||||
extern int file_write(struct m_inode * inode, struct file * filp,
|
||||
char * buf, int count);
|
||||
|
||||
int sys_lseek(unsigned int fd,off_t offset, int origin)
|
||||
{
|
||||
struct file * file;
|
||||
int tmp;
|
||||
|
||||
if (fd >= NR_OPEN || !(file=current->filp[fd]) || !(file->f_inode)
|
||||
|| !IS_SEEKABLE(MAJOR(file->f_inode->i_dev)))
|
||||
return -EBADF;
|
||||
if (file->f_inode->i_pipe)
|
||||
return -ESPIPE;
|
||||
switch (origin) {
|
||||
case 0:
|
||||
if (offset<0) return -EINVAL;
|
||||
file->f_pos=offset;
|
||||
break;
|
||||
case 1:
|
||||
if (file->f_pos+offset<0) return -EINVAL;
|
||||
file->f_pos += offset;
|
||||
break;
|
||||
case 2:
|
||||
if ((tmp=file->f_inode->i_size+offset) < 0)
|
||||
return -EINVAL;
|
||||
file->f_pos = tmp;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
return file->f_pos;
|
||||
}
|
||||
|
||||
int sys_read(unsigned int fd,char * buf,int count)
|
||||
{
|
||||
struct file * file;
|
||||
struct m_inode * inode;
|
||||
|
||||
if (fd>=NR_OPEN || count<0 || !(file=current->filp[fd]))
|
||||
return -EINVAL;
|
||||
if (!count)
|
||||
return 0;
|
||||
verify_area(buf,count);
|
||||
inode = file->f_inode;
|
||||
if (inode->i_pipe)
|
||||
return (file->f_mode&1)?read_pipe(inode,buf,count):-EIO;
|
||||
if (S_ISCHR(inode->i_mode))
|
||||
return rw_char(READ,inode->i_zone[0],buf,count,&file->f_pos);
|
||||
if (S_ISBLK(inode->i_mode))
|
||||
return block_read(inode->i_zone[0],&file->f_pos,buf,count);
|
||||
if (S_ISDIR(inode->i_mode) || S_ISREG(inode->i_mode)) {
|
||||
if (count+file->f_pos > inode->i_size)
|
||||
count = inode->i_size - file->f_pos;
|
||||
if (count<=0)
|
||||
return 0;
|
||||
return file_read(inode,file,buf,count);
|
||||
}
|
||||
printk("(Read)inode->i_mode=%06o\n\r",inode->i_mode);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int sys_write(unsigned int fd,char * buf,int count)
|
||||
{
|
||||
struct file * file;
|
||||
struct m_inode * inode;
|
||||
|
||||
if (fd>=NR_OPEN || count <0 || !(file=current->filp[fd]))
|
||||
return -EINVAL;
|
||||
if (!count)
|
||||
return 0;
|
||||
inode=file->f_inode;
|
||||
if (inode->i_pipe)
|
||||
return (file->f_mode&2)?write_pipe(inode,buf,count):-EIO;
|
||||
if (S_ISCHR(inode->i_mode))
|
||||
return rw_char(WRITE,inode->i_zone[0],buf,count,&file->f_pos);
|
||||
if (S_ISBLK(inode->i_mode))
|
||||
return block_write(inode->i_zone[0],&file->f_pos,buf,count);
|
||||
if (S_ISREG(inode->i_mode))
|
||||
return file_write(inode,file,buf,count);
|
||||
printk("(Write)inode->i_mode=%06o\n\r",inode->i_mode);
|
||||
return -EINVAL;
|
||||
}
|
||||
Binary file not shown.
@ -1,10 +0,0 @@
|
||||
/* nothing , only the stub */
|
||||
/* gohigh */
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
int sys_select()
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
Binary file not shown.
@ -1,66 +0,0 @@
|
||||
/*
|
||||
* linux/fs/stat.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <linux/fs.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
static void cp_stat(struct m_inode * inode, struct stat * statbuf)
|
||||
{
|
||||
struct stat tmp;
|
||||
int i;
|
||||
|
||||
verify_area(statbuf,sizeof (* statbuf));
|
||||
tmp.st_dev = inode->i_dev;
|
||||
tmp.st_ino = inode->i_num;
|
||||
tmp.st_mode = inode->i_mode;
|
||||
tmp.st_nlink = inode->i_nlinks;
|
||||
tmp.st_uid = inode->i_uid;
|
||||
tmp.st_gid = inode->i_gid;
|
||||
tmp.st_rdev = inode->i_zone[0];
|
||||
tmp.st_size = inode->i_size;
|
||||
tmp.st_atime = inode->i_atime;
|
||||
tmp.st_mtime = inode->i_mtime;
|
||||
tmp.st_ctime = inode->i_ctime;
|
||||
for (i=0 ; i<sizeof (tmp) ; i++)
|
||||
put_fs_byte(((char *) &tmp)[i],&((char *) statbuf)[i]);
|
||||
}
|
||||
|
||||
int sys_stat(char * filename, struct stat * statbuf)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
|
||||
if (!(inode=namei(filename)))
|
||||
return -ENOENT;
|
||||
cp_stat(inode,statbuf);
|
||||
iput(inode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_lstat(char * filename, struct stat * statbuf)
|
||||
{
|
||||
return sys_stat(filename, statbuf);
|
||||
}
|
||||
|
||||
int sys_fstat(unsigned int fd, struct stat * statbuf)
|
||||
{
|
||||
struct file * f;
|
||||
struct m_inode * inode;
|
||||
|
||||
if (fd >= NR_OPEN || !(f=current->filp[fd]) || !(inode=f->f_inode))
|
||||
return -EBADF;
|
||||
cp_stat(inode,statbuf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_readlink()
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
@ -1,282 +0,0 @@
|
||||
/*
|
||||
* linux/fs/super.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* super.c contains code to handle the super-block tables.
|
||||
*/
|
||||
#include <linux/config.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/system.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
int sync_dev(int dev);
|
||||
void wait_for_keypress(void);
|
||||
|
||||
/* set_bit uses setb, as gas doesn't recognize setc */
|
||||
#define set_bit(bitnr,addr) ({ \
|
||||
register int __res __asm__("ax"); \
|
||||
__asm__("bt %2,%3;setb %%al":"=a" (__res):"a" (0),"r" (bitnr),"m" (*(addr))); \
|
||||
__res; })
|
||||
|
||||
struct super_block super_block[NR_SUPER];
|
||||
/* this is initialized in init/main.c */
|
||||
int ROOT_DEV = 0;
|
||||
|
||||
static void lock_super(struct super_block * sb)
|
||||
{
|
||||
cli();
|
||||
while (sb->s_lock)
|
||||
sleep_on(&(sb->s_wait));
|
||||
sb->s_lock = 1;
|
||||
sti();
|
||||
}
|
||||
|
||||
static void free_super(struct super_block * sb)
|
||||
{
|
||||
cli();
|
||||
sb->s_lock = 0;
|
||||
wake_up(&(sb->s_wait));
|
||||
sti();
|
||||
}
|
||||
|
||||
static void wait_on_super(struct super_block * sb)
|
||||
{
|
||||
cli();
|
||||
while (sb->s_lock)
|
||||
sleep_on(&(sb->s_wait));
|
||||
sti();
|
||||
}
|
||||
|
||||
struct super_block * get_super(int dev)
|
||||
{
|
||||
struct super_block * s;
|
||||
|
||||
if (!dev)
|
||||
return NULL;
|
||||
s = 0+super_block;
|
||||
while (s < NR_SUPER+super_block)
|
||||
if (s->s_dev == dev) {
|
||||
wait_on_super(s);
|
||||
if (s->s_dev == dev)
|
||||
return s;
|
||||
s = 0+super_block;
|
||||
} else
|
||||
s++;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void put_super(int dev)
|
||||
{
|
||||
struct super_block * sb;
|
||||
/* struct m_inode * inode; */
|
||||
int i;
|
||||
|
||||
if (dev == ROOT_DEV) {
|
||||
printk("root diskette changed: prepare for armageddon\n\r");
|
||||
return;
|
||||
}
|
||||
if (!(sb = get_super(dev)))
|
||||
return;
|
||||
if (sb->s_imount) {
|
||||
printk("Mounted disk changed - tssk, tssk\n\r");
|
||||
return;
|
||||
}
|
||||
lock_super(sb);
|
||||
sb->s_dev = 0;
|
||||
for(i=0;i<I_MAP_SLOTS;i++)
|
||||
brelse(sb->s_imap[i]);
|
||||
for(i=0;i<Z_MAP_SLOTS;i++)
|
||||
brelse(sb->s_zmap[i]);
|
||||
free_super(sb);
|
||||
return;
|
||||
}
|
||||
|
||||
static struct super_block * read_super(int dev)
|
||||
{
|
||||
struct super_block * s;
|
||||
struct buffer_head * bh;
|
||||
int i,block;
|
||||
|
||||
if (!dev)
|
||||
return NULL;
|
||||
check_disk_change(dev);
|
||||
if (s = get_super(dev))
|
||||
return s;
|
||||
for (s = 0+super_block ;; s++) {
|
||||
if (s >= NR_SUPER+super_block)
|
||||
return NULL;
|
||||
if (!s->s_dev)
|
||||
break;
|
||||
}
|
||||
s->s_dev = dev;
|
||||
s->s_isup = NULL;
|
||||
s->s_imount = NULL;
|
||||
s->s_time = 0;
|
||||
s->s_rd_only = 0;
|
||||
s->s_dirt = 0;
|
||||
lock_super(s);
|
||||
if (!(bh = bread(dev,1))) {
|
||||
s->s_dev=0;
|
||||
free_super(s);
|
||||
return NULL;
|
||||
}
|
||||
__asm__ volatile ("cld"); /* by wyj */
|
||||
*((struct d_super_block *) s) =
|
||||
*((struct d_super_block *) bh->b_data);
|
||||
brelse(bh);
|
||||
if (s->s_magic != SUPER_MAGIC) {
|
||||
s->s_dev = 0;
|
||||
free_super(s);
|
||||
return NULL;
|
||||
}
|
||||
for (i=0;i<I_MAP_SLOTS;i++)
|
||||
s->s_imap[i] = NULL;
|
||||
for (i=0;i<Z_MAP_SLOTS;i++)
|
||||
s->s_zmap[i] = NULL;
|
||||
block=2;
|
||||
for (i=0 ; i < s->s_imap_blocks ; i++)
|
||||
if (s->s_imap[i]=bread(dev,block))
|
||||
block++;
|
||||
else
|
||||
break;
|
||||
for (i=0 ; i < s->s_zmap_blocks ; i++)
|
||||
if (s->s_zmap[i]=bread(dev,block))
|
||||
block++;
|
||||
else
|
||||
break;
|
||||
if (block != 2+s->s_imap_blocks+s->s_zmap_blocks) {
|
||||
for(i=0;i<I_MAP_SLOTS;i++)
|
||||
brelse(s->s_imap[i]);
|
||||
for(i=0;i<Z_MAP_SLOTS;i++)
|
||||
brelse(s->s_zmap[i]);
|
||||
s->s_dev=0;
|
||||
free_super(s);
|
||||
return NULL;
|
||||
}
|
||||
s->s_imap[0]->b_data[0] |= 1;
|
||||
s->s_zmap[0]->b_data[0] |= 1;
|
||||
free_super(s);
|
||||
return s;
|
||||
}
|
||||
|
||||
int sys_umount(char * dev_name)
|
||||
{
|
||||
struct m_inode * inode;
|
||||
struct super_block * sb;
|
||||
int dev;
|
||||
|
||||
if (!(inode=namei(dev_name)))
|
||||
return -ENOENT;
|
||||
dev = inode->i_zone[0];
|
||||
if (!S_ISBLK(inode->i_mode)) {
|
||||
iput(inode);
|
||||
return -ENOTBLK;
|
||||
}
|
||||
iput(inode);
|
||||
if (dev==ROOT_DEV)
|
||||
return -EBUSY;
|
||||
if (!(sb=get_super(dev)) || !(sb->s_imount))
|
||||
return -ENOENT;
|
||||
if (!sb->s_imount->i_mount)
|
||||
printk("Mounted inode has i_mount=0\n");
|
||||
for (inode=inode_table+0 ; inode<inode_table+NR_INODE ; inode++)
|
||||
if (inode->i_dev==dev && inode->i_count)
|
||||
return -EBUSY;
|
||||
sb->s_imount->i_mount=0;
|
||||
iput(sb->s_imount);
|
||||
sb->s_imount = NULL;
|
||||
iput(sb->s_isup);
|
||||
sb->s_isup = NULL;
|
||||
put_super(dev);
|
||||
sync_dev(dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sys_mount(char * dev_name, char * dir_name, int rw_flag)
|
||||
{
|
||||
struct m_inode * dev_i, * dir_i;
|
||||
struct super_block * sb;
|
||||
int dev;
|
||||
|
||||
if (!(dev_i=namei(dev_name)))
|
||||
return -ENOENT;
|
||||
dev = dev_i->i_zone[0];
|
||||
if (!S_ISBLK(dev_i->i_mode)) {
|
||||
iput(dev_i);
|
||||
return -EPERM;
|
||||
}
|
||||
iput(dev_i);
|
||||
if (!(dir_i=namei(dir_name)))
|
||||
return -ENOENT;
|
||||
if (dir_i->i_count != 1 || dir_i->i_num == ROOT_INO) {
|
||||
iput(dir_i);
|
||||
return -EBUSY;
|
||||
}
|
||||
if (!S_ISDIR(dir_i->i_mode)) {
|
||||
iput(dir_i);
|
||||
return -EPERM;
|
||||
}
|
||||
if (!(sb=read_super(dev))) {
|
||||
iput(dir_i);
|
||||
return -EBUSY;
|
||||
}
|
||||
if (sb->s_imount) {
|
||||
iput(dir_i);
|
||||
return -EBUSY;
|
||||
}
|
||||
if (dir_i->i_mount) {
|
||||
iput(dir_i);
|
||||
return -EPERM;
|
||||
}
|
||||
sb->s_imount=dir_i;
|
||||
dir_i->i_mount=1;
|
||||
dir_i->i_dirt=1; /* NOTE! we don't iput(dir_i) */
|
||||
return 0; /* we do that in umount */
|
||||
}
|
||||
|
||||
void mount_root(void)
|
||||
{
|
||||
int i,free;
|
||||
struct super_block * p;
|
||||
struct m_inode * mi;
|
||||
|
||||
if (32 != sizeof (struct d_inode))
|
||||
panic("bad i-node size");
|
||||
for(i=0;i<NR_FILE;i++)
|
||||
file_table[i].f_count=0;
|
||||
if (MAJOR(ROOT_DEV) == 2) {
|
||||
printk("Insert root floppy and press ENTER");
|
||||
wait_for_keypress();
|
||||
}
|
||||
for(p = &super_block[0] ; p < &super_block[NR_SUPER] ; p++) {
|
||||
p->s_dev = 0;
|
||||
p->s_lock = 0;
|
||||
p->s_wait = NULL;
|
||||
}
|
||||
if (!(p=read_super(ROOT_DEV)))
|
||||
panic("Unable to mount root");
|
||||
if (!(mi=iget(ROOT_DEV,ROOT_INO)))
|
||||
panic("Unable to read root i-node");
|
||||
mi->i_count += 3 ; /* NOTE! it is logically used 4 times, not 1 */
|
||||
p->s_isup = p->s_imount = mi;
|
||||
current->pwd = mi;
|
||||
current->root = mi;
|
||||
free=0;
|
||||
i=p->s_nzones;
|
||||
while (-- i >= 0)
|
||||
if (!set_bit(i&8191,p->s_zmap[i>>13]->b_data))
|
||||
free++;
|
||||
printk("%d/%d free blocks\n\r",free,p->s_nzones);
|
||||
free=0;
|
||||
i=p->s_ninodes+1;
|
||||
while (-- i >= 0)
|
||||
if (!set_bit(i&8191,p->s_imap[i>>13]->b_data))
|
||||
free++;
|
||||
printk("%d/%d free inodes\n\r",free,p->s_ninodes);
|
||||
}
|
||||
Binary file not shown.
@ -1,65 +0,0 @@
|
||||
/*
|
||||
* linux/fs/truncate.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#include <linux/sched.h>
|
||||
|
||||
#include <sys/stat.h>
|
||||
|
||||
static void free_ind(int dev,int block)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
unsigned short * p;
|
||||
int i;
|
||||
|
||||
if (!block)
|
||||
return;
|
||||
if (bh=bread(dev,block)) {
|
||||
p = (unsigned short *) bh->b_data;
|
||||
for (i=0;i<512;i++,p++)
|
||||
if (*p)
|
||||
free_block(dev,*p);
|
||||
brelse(bh);
|
||||
}
|
||||
free_block(dev,block);
|
||||
}
|
||||
|
||||
static void free_dind(int dev,int block)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
unsigned short * p;
|
||||
int i;
|
||||
|
||||
if (!block)
|
||||
return;
|
||||
if (bh=bread(dev,block)) {
|
||||
p = (unsigned short *) bh->b_data;
|
||||
for (i=0;i<512;i++,p++)
|
||||
if (*p)
|
||||
free_ind(dev,*p);
|
||||
brelse(bh);
|
||||
}
|
||||
free_block(dev,block);
|
||||
}
|
||||
|
||||
void truncate(struct m_inode * inode)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
|
||||
return;
|
||||
for (i=0;i<7;i++)
|
||||
if (inode->i_zone[i]) {
|
||||
free_block(inode->i_dev,inode->i_zone[i]);
|
||||
inode->i_zone[i]=0;
|
||||
}
|
||||
free_ind(inode->i_dev,inode->i_zone[7]);
|
||||
free_dind(inode->i_dev,inode->i_zone[8]);
|
||||
inode->i_zone[7] = inode->i_zone[8] = 0;
|
||||
inode->i_size = 0;
|
||||
inode->i_dirt = 1;
|
||||
inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
||||
}
|
||||
|
||||
Binary file not shown.
@ -1,220 +0,0 @@
|
||||
#ifndef _A_OUT_H
|
||||
#define _A_OUT_H
|
||||
|
||||
#define __GNU_EXEC_MACROS__
|
||||
|
||||
struct exec {
|
||||
unsigned long a_magic; /* Use macros N_MAGIC, etc for access */
|
||||
unsigned a_text; /* length of text, in bytes */
|
||||
unsigned a_data; /* length of data, in bytes */
|
||||
unsigned a_bss; /* length of uninitialized data area for file, in bytes */
|
||||
unsigned a_syms; /* length of symbol table data in file, in bytes */
|
||||
unsigned a_entry; /* start address */
|
||||
unsigned a_trsize; /* length of relocation info for text, in bytes */
|
||||
unsigned a_drsize; /* length of relocation info for data, in bytes */
|
||||
};
|
||||
|
||||
#ifndef N_MAGIC
|
||||
#define N_MAGIC(exec) ((exec).a_magic)
|
||||
#endif
|
||||
|
||||
#ifndef OMAGIC
|
||||
/* Code indicating object file or impure executable. */
|
||||
#define OMAGIC 0407
|
||||
/* Code indicating pure executable. */
|
||||
#define NMAGIC 0410
|
||||
/* Code indicating demand-paged executable. */
|
||||
#define ZMAGIC 0413
|
||||
#endif /* not OMAGIC */
|
||||
|
||||
#ifndef N_BADMAG
|
||||
#define N_BADMAG(x) \
|
||||
(N_MAGIC(x) != OMAGIC && N_MAGIC(x) != NMAGIC \
|
||||
&& N_MAGIC(x) != ZMAGIC)
|
||||
#endif
|
||||
|
||||
#define _N_BADMAG(x) \
|
||||
(N_MAGIC(x) != OMAGIC && N_MAGIC(x) != NMAGIC \
|
||||
&& N_MAGIC(x) != ZMAGIC)
|
||||
|
||||
#define _N_HDROFF(x) (SEGMENT_SIZE - sizeof (struct exec))
|
||||
|
||||
#ifndef N_TXTOFF
|
||||
#define N_TXTOFF(x) \
|
||||
(N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : sizeof (struct exec))
|
||||
#endif
|
||||
|
||||
#ifndef N_DATOFF
|
||||
#define N_DATOFF(x) (N_TXTOFF(x) + (x).a_text)
|
||||
#endif
|
||||
|
||||
#ifndef N_TRELOFF
|
||||
#define N_TRELOFF(x) (N_DATOFF(x) + (x).a_data)
|
||||
#endif
|
||||
|
||||
#ifndef N_DRELOFF
|
||||
#define N_DRELOFF(x) (N_TRELOFF(x) + (x).a_trsize)
|
||||
#endif
|
||||
|
||||
#ifndef N_SYMOFF
|
||||
#define N_SYMOFF(x) (N_DRELOFF(x) + (x).a_drsize)
|
||||
#endif
|
||||
|
||||
#ifndef N_STROFF
|
||||
#define N_STROFF(x) (N_SYMOFF(x) + (x).a_syms)
|
||||
#endif
|
||||
|
||||
/* Address of text segment in memory after it is loaded. */
|
||||
#ifndef N_TXTADDR
|
||||
#define N_TXTADDR(x) 0
|
||||
#endif
|
||||
|
||||
/* Address of data segment in memory after it is loaded.
|
||||
Note that it is up to you to define SEGMENT_SIZE
|
||||
on machines not listed here. */
|
||||
#if defined(vax) || defined(hp300) || defined(pyr)
|
||||
#define SEGMENT_SIZE PAGE_SIZE
|
||||
#endif
|
||||
#ifdef hp300
|
||||
#define PAGE_SIZE 4096
|
||||
#endif
|
||||
#ifdef sony
|
||||
#define SEGMENT_SIZE 0x2000
|
||||
#endif /* Sony. */
|
||||
#ifdef is68k
|
||||
#define SEGMENT_SIZE 0x20000
|
||||
#endif
|
||||
#if defined(m68k) && defined(PORTAR)
|
||||
#define PAGE_SIZE 0x400
|
||||
#define SEGMENT_SIZE PAGE_SIZE
|
||||
#endif
|
||||
|
||||
#define PAGE_SIZE 4096
|
||||
#define SEGMENT_SIZE 1024
|
||||
|
||||
#define _N_SEGMENT_ROUND(x) (((x) + SEGMENT_SIZE - 1) & ~(SEGMENT_SIZE - 1))
|
||||
|
||||
#define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text)
|
||||
|
||||
#ifndef N_DATADDR
|
||||
#define N_DATADDR(x) \
|
||||
(N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x)) \
|
||||
: (_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
|
||||
#endif
|
||||
|
||||
/* Address of bss segment in memory after it is loaded. */
|
||||
#ifndef N_BSSADDR
|
||||
#define N_BSSADDR(x) (N_DATADDR(x) + (x).a_data)
|
||||
#endif
|
||||
|
||||
#ifndef N_NLIST_DECLARED
|
||||
struct nlist {
|
||||
union {
|
||||
char *n_name;
|
||||
struct nlist *n_next;
|
||||
long n_strx;
|
||||
} n_un;
|
||||
unsigned char n_type;
|
||||
char n_other;
|
||||
short n_desc;
|
||||
unsigned long n_value;
|
||||
};
|
||||
#endif
|
||||
|
||||
#ifndef N_UNDF
|
||||
#define N_UNDF 0
|
||||
#endif
|
||||
#ifndef N_ABS
|
||||
#define N_ABS 2
|
||||
#endif
|
||||
#ifndef N_TEXT
|
||||
#define N_TEXT 4
|
||||
#endif
|
||||
#ifndef N_DATA
|
||||
#define N_DATA 6
|
||||
#endif
|
||||
#ifndef N_BSS
|
||||
#define N_BSS 8
|
||||
#endif
|
||||
#ifndef N_COMM
|
||||
#define N_COMM 18
|
||||
#endif
|
||||
#ifndef N_FN
|
||||
#define N_FN 15
|
||||
#endif
|
||||
|
||||
#ifndef N_EXT
|
||||
#define N_EXT 1
|
||||
#endif
|
||||
#ifndef N_TYPE
|
||||
#define N_TYPE 036
|
||||
#endif
|
||||
#ifndef N_STAB
|
||||
#define N_STAB 0340
|
||||
#endif
|
||||
|
||||
/* The following type indicates the definition of a symbol as being
|
||||
an indirect reference to another symbol. The other symbol
|
||||
appears as an undefined reference, immediately following this symbol.
|
||||
|
||||
Indirection is asymmetrical. The other symbol's value will be used
|
||||
to satisfy requests for the indirect symbol, but not vice versa.
|
||||
If the other symbol does not have a definition, libraries will
|
||||
be searched to find a definition. */
|
||||
#define N_INDR 0xa
|
||||
|
||||
/* The following symbols refer to set elements.
|
||||
All the N_SET[ATDB] symbols with the same name form one set.
|
||||
Space is allocated for the set in the text section, and each set
|
||||
element's value is stored into one word of the space.
|
||||
The first word of the space is the length of the set (number of elements).
|
||||
|
||||
The address of the set is made into an N_SETV symbol
|
||||
whose name is the same as the name of the set.
|
||||
This symbol acts like a N_DATA global symbol
|
||||
in that it can satisfy undefined external references. */
|
||||
|
||||
/* These appear as input to LD, in a .o file. */
|
||||
#define N_SETA 0x14 /* Absolute set element symbol */
|
||||
#define N_SETT 0x16 /* Text set element symbol */
|
||||
#define N_SETD 0x18 /* Data set element symbol */
|
||||
#define N_SETB 0x1A /* Bss set element symbol */
|
||||
|
||||
/* This is output from LD. */
|
||||
#define N_SETV 0x1C /* Pointer to set vector in data area. */
|
||||
|
||||
#ifndef N_RELOCATION_INFO_DECLARED
|
||||
|
||||
/* This structure describes a single relocation to be performed.
|
||||
The text-relocation section of the file is a vector of these structures,
|
||||
all of which apply to the text section.
|
||||
Likewise, the data-relocation section applies to the data section. */
|
||||
|
||||
struct relocation_info
|
||||
{
|
||||
/* Address (within segment) to be relocated. */
|
||||
int r_address;
|
||||
/* The meaning of r_symbolnum depends on r_extern. */
|
||||
unsigned int r_symbolnum:24;
|
||||
/* Nonzero means value is a pc-relative offset
|
||||
and it should be relocated for changes in its own address
|
||||
as well as for changes in the symbol or section specified. */
|
||||
unsigned int r_pcrel:1;
|
||||
/* Length (as exponent of 2) of the field to be relocated.
|
||||
Thus, a value of 2 indicates 1<<2 bytes. */
|
||||
unsigned int r_length:2;
|
||||
/* 1 => relocate with value of symbol.
|
||||
r_symbolnum is the index of the symbol
|
||||
in file's the symbol table.
|
||||
0 => relocate with the address of a segment.
|
||||
r_symbolnum is N_TEXT, N_DATA, N_BSS or N_ABS
|
||||
(the N_EXT bit may be set also, but signifies nothing). */
|
||||
unsigned int r_extern:1;
|
||||
/* Four bits that aren't used, but when writing an object file
|
||||
it is desirable to clear them. */
|
||||
unsigned int r_pad:4;
|
||||
};
|
||||
#endif /* no N_RELOCATION_INFO_DECLARED. */
|
||||
|
||||
|
||||
#endif /* __A_OUT_GNU_H__ */
|
||||
@ -1,24 +0,0 @@
|
||||
#define outb(value,port) \
|
||||
__asm__ ("outb %%al,%%dx"::"a" (value),"d" (port))
|
||||
|
||||
|
||||
#define inb(port) ({ \
|
||||
unsigned char _v; \
|
||||
__asm__ volatile ("inb %%dx,%%al":"=a" (_v):"d" (port)); \
|
||||
_v; \
|
||||
})
|
||||
|
||||
#define outb_p(value,port) \
|
||||
__asm__ ("outb %%al,%%dx\n" \
|
||||
"\tjmp 1f\n" \
|
||||
"1:\tjmp 1f\n" \
|
||||
"1:"::"a" (value),"d" (port))
|
||||
|
||||
#define inb_p(port) ({ \
|
||||
unsigned char _v; \
|
||||
__asm__ volatile ("inb %%dx,%%al\n" \
|
||||
"\tjmp 1f\n" \
|
||||
"1:\tjmp 1f\n" \
|
||||
"1:":"=a" (_v):"d" (port)); \
|
||||
_v; \
|
||||
})
|
||||
@ -1,15 +0,0 @@
|
||||
/*
|
||||
* NOTE!!! memcpy(dest,src,n) assumes ds=es=normal data segment. This
|
||||
* goes for all kernel functions (ds=es=kernel space, fs=local data,
|
||||
* gs=null), as well as for all well-behaving user programs (ds=es=
|
||||
* user data space). This is NOT a bug, as any user program that changes
|
||||
* es deserves to die if it isn't careful.
|
||||
*/
|
||||
#define memcpy(dest,src,n) ({ \
|
||||
void * _res = dest; \
|
||||
__asm__ ("cld;rep;movsb" \
|
||||
::"D" ((long)(_res)),"S" ((long)(src)),"c" ((long) (n)) \
|
||||
); \
|
||||
_res; \
|
||||
})
|
||||
|
||||
@ -1,65 +0,0 @@
|
||||
static inline unsigned char get_fs_byte(const char * addr)
|
||||
{
|
||||
unsigned register char _v;
|
||||
|
||||
__asm__ ("movb %%fs:%1,%0":"=r" (_v):"m" (*addr));
|
||||
return _v;
|
||||
}
|
||||
|
||||
static inline unsigned short get_fs_word(const unsigned short *addr)
|
||||
{
|
||||
unsigned short _v;
|
||||
|
||||
__asm__ ("movw %%fs:%1,%0":"=r" (_v):"m" (*addr));
|
||||
return _v;
|
||||
}
|
||||
|
||||
static inline unsigned long get_fs_long(const unsigned long *addr)
|
||||
{
|
||||
unsigned long _v;
|
||||
|
||||
__asm__ ("movl %%fs:%1,%0":"=r" (_v):"m" (*addr)); \
|
||||
return _v;
|
||||
}
|
||||
|
||||
static inline void put_fs_byte(char val,char *addr)
|
||||
{
|
||||
__asm__ ("movb %0,%%fs:%1"::"r" (val),"m" (*addr));
|
||||
}
|
||||
|
||||
static inline void put_fs_word(short val,short * addr)
|
||||
{
|
||||
__asm__ ("movw %0,%%fs:%1"::"r" (val),"m" (*addr));
|
||||
}
|
||||
|
||||
static inline void put_fs_long(unsigned long val,unsigned long * addr)
|
||||
{
|
||||
__asm__ ("movl %0,%%fs:%1"::"r" (val),"m" (*addr));
|
||||
}
|
||||
|
||||
/*
|
||||
* Someone who knows GNU asm better than I should double check the followig.
|
||||
* It seems to work, but I don't know if I'm doing something subtly wrong.
|
||||
* --- TYT, 11/24/91
|
||||
* [ nothing wrong here, Linus ]
|
||||
*/
|
||||
|
||||
static inline unsigned long get_fs()
|
||||
{
|
||||
unsigned short _v;
|
||||
__asm__("mov %%fs,%%ax":"=a" (_v):);
|
||||
return _v;
|
||||
}
|
||||
|
||||
static inline unsigned long get_ds()
|
||||
{
|
||||
unsigned short _v;
|
||||
__asm__("mov %%ds,%%ax":"=a" (_v):);
|
||||
return _v;
|
||||
}
|
||||
|
||||
static inline void set_fs(unsigned long val)
|
||||
{
|
||||
__asm__("mov %0,%%fs"::"a" ((unsigned short) val));
|
||||
}
|
||||
|
||||
@ -1,66 +0,0 @@
|
||||
#define move_to_user_mode() \
|
||||
__asm__ ("movl %%esp,%%eax\n\t" \
|
||||
"pushl $0x17\n\t" \
|
||||
"pushl %%eax\n\t" \
|
||||
"pushfl\n\t" \
|
||||
"pushl $0x0f\n\t" \
|
||||
"pushl $1f\n\t" \
|
||||
"iret\n" \
|
||||
"1:\tmovl $0x17,%%eax\n\t" \
|
||||
"movw %%ax,%%ds\n\t" \
|
||||
"movw %%ax,%%es\n\t" \
|
||||
"movw %%ax,%%fs\n\t" \
|
||||
"movw %%ax,%%gs" \
|
||||
:::"ax")
|
||||
|
||||
#define sti() __asm__ ("sti"::)
|
||||
#define cli() __asm__ ("cli"::)
|
||||
#define nop() __asm__ ("nop"::)
|
||||
|
||||
#define iret() __asm__ ("iret"::)
|
||||
|
||||
#define _set_gate(gate_addr,type,dpl,addr) \
|
||||
__asm__ ("movw %%dx,%%ax\n\t" \
|
||||
"movw %0,%%dx\n\t" \
|
||||
"movl %%eax,%1\n\t" \
|
||||
"movl %%edx,%2" \
|
||||
: \
|
||||
: "i" ((short) (0x8000+(dpl<<13)+(type<<8))), \
|
||||
"o" (*((char *) (gate_addr))), \
|
||||
"o" (*(4+(char *) (gate_addr))), \
|
||||
"d" ((char *) (addr)),"a" (0x00080000))
|
||||
|
||||
#define set_intr_gate(n,addr) \
|
||||
_set_gate(&idt[n],14,0,addr)
|
||||
|
||||
#define set_trap_gate(n,addr) \
|
||||
_set_gate(&idt[n],15,0,addr)
|
||||
|
||||
#define set_system_gate(n,addr) \
|
||||
_set_gate(&idt[n],15,3,addr)
|
||||
|
||||
#define _set_seg_desc(gate_addr,type,dpl,base,limit) {\
|
||||
*(gate_addr) = ((base) & 0xff000000) | \
|
||||
(((base) & 0x00ff0000)>>16) | \
|
||||
((limit) & 0xf0000) | \
|
||||
((dpl)<<13) | \
|
||||
(0x00408000) | \
|
||||
((type)<<8); \
|
||||
*((gate_addr)+1) = (((base) & 0x0000ffff)<<16) | \
|
||||
((limit) & 0x0ffff); }
|
||||
|
||||
#define _set_tssldt_desc(n,addr,type) \
|
||||
__asm__ ("movw $104,%1\n\t" \
|
||||
"movw %%ax,%2\n\t" \
|
||||
"rorl $16,%%eax\n\t" \
|
||||
"movb %%al,%3\n\t" \
|
||||
"movb $" type ",%4\n\t" \
|
||||
"movb $0x00,%5\n\t" \
|
||||
"movb %%ah,%6\n\t" \
|
||||
"rorl $16,%%eax" \
|
||||
::"a" (addr), "m" (*(n)), "m" (*(n+2)), "m" (*(n+4)), \
|
||||
"m" (*(n+5)), "m" (*(n+6)), "m" (*(n+7)) \
|
||||
)
|
||||
|
||||
#define set_tss_desc(n,addr) _set_tssldt_desc(((char *) (n)),addr,"0x89")
|
||||
#define set_ldt_desc(n,addr) _set_tssldt_desc(((char *) (n)),addr,"0x82")
|
||||
@ -1,15 +0,0 @@
|
||||
#ifndef _CONST_H
|
||||
#define _CONST_H
|
||||
|
||||
#define BUFFER_END 0x200000
|
||||
|
||||
#define I_TYPE 0170000
|
||||
#define I_DIRECTORY 0040000
|
||||
#define I_REGULAR 0100000
|
||||
#define I_BLOCK_SPECIAL 0060000
|
||||
#define I_CHAR_SPECIAL 0020000
|
||||
#define I_NAMED_PIPE 0010000
|
||||
#define I_SET_UID_BIT 0004000
|
||||
#define I_SET_GID_BIT 0002000
|
||||
|
||||
#endif
|
||||
@ -1,34 +0,0 @@
|
||||
#ifndef _CTYPE_H
|
||||
#define _CTYPE_H
|
||||
|
||||
#define _U 0x01 /* upper */
|
||||
#define _L 0x02 /* lower */
|
||||
#define _D 0x04 /* digit */
|
||||
#define _C 0x08 /* cntrl */
|
||||
#define _P 0x10 /* punct */
|
||||
#define _S 0x20 /* white space (space/lf/tab) */
|
||||
#define _X 0x40 /* hex digit */
|
||||
#define _SP 0x80 /* hard space (0x20) */
|
||||
|
||||
extern unsigned char _ctype[];
|
||||
extern char _ctmp;
|
||||
|
||||
#define isalnum(c) ((_ctype+1)[c]&(_U|_L|_D))
|
||||
#define isalpha(c) ((_ctype+1)[c]&(_U|_L))
|
||||
#define iscntrl(c) ((_ctype+1)[c]&(_C))
|
||||
#define isdigit(c) ((_ctype+1)[c]&(_D))
|
||||
#define isgraph(c) ((_ctype+1)[c]&(_P|_U|_L|_D))
|
||||
#define islower(c) ((_ctype+1)[c]&(_L))
|
||||
#define isprint(c) ((_ctype+1)[c]&(_P|_U|_L|_D|_SP))
|
||||
#define ispunct(c) ((_ctype+1)[c]&(_P))
|
||||
#define isspace(c) ((_ctype+1)[c]&(_S))
|
||||
#define isupper(c) ((_ctype+1)[c]&(_U))
|
||||
#define isxdigit(c) ((_ctype+1)[c]&(_D|_X))
|
||||
|
||||
#define isascii(c) (((unsigned) c)<=0x7f)
|
||||
#define toascii(c) (((unsigned) c)&0x7f)
|
||||
|
||||
#define tolower(c) (_ctmp=c,isupper(_ctmp)?_ctmp-('A'-'a'):_ctmp)
|
||||
#define toupper(c) (_ctmp=c,islower(_ctmp)?_ctmp-('a'-'A'):_ctmp)
|
||||
|
||||
#endif
|
||||
@ -1,60 +0,0 @@
|
||||
#ifndef _ERRNO_H
|
||||
#define _ERRNO_H
|
||||
|
||||
/*
|
||||
* ok, as I hadn't got any other source of information about
|
||||
* possible error numbers, I was forced to use the same numbers
|
||||
* as minix.
|
||||
* Hopefully these are posix or something. I wouldn't know (and posix
|
||||
* isn't telling me - they want $$$ for their f***ing standard).
|
||||
*
|
||||
* We don't use the _SIGN cludge of minix, so kernel returns must
|
||||
* see to the sign by themselves.
|
||||
*
|
||||
* NOTE! Remember to change strerror() if you change this file!
|
||||
*/
|
||||
|
||||
extern int errno;
|
||||
|
||||
#define ERROR 99
|
||||
#define EPERM 1
|
||||
#define ENOENT 2
|
||||
#define ESRCH 3
|
||||
#define EINTR 4
|
||||
#define EIO 5
|
||||
#define ENXIO 6
|
||||
#define E2BIG 7
|
||||
#define ENOEXEC 8
|
||||
#define EBADF 9
|
||||
#define ECHILD 10
|
||||
#define EAGAIN 11
|
||||
#define ENOMEM 12
|
||||
#define EACCES 13
|
||||
#define EFAULT 14
|
||||
#define ENOTBLK 15
|
||||
#define EBUSY 16
|
||||
#define EEXIST 17
|
||||
#define EXDEV 18
|
||||
#define ENODEV 19
|
||||
#define ENOTDIR 20
|
||||
#define EISDIR 21
|
||||
#define EINVAL 22
|
||||
#define ENFILE 23
|
||||
#define EMFILE 24
|
||||
#define ENOTTY 25
|
||||
#define ETXTBSY 26
|
||||
#define EFBIG 27
|
||||
#define ENOSPC 28
|
||||
#define ESPIPE 29
|
||||
#define EROFS 30
|
||||
#define EMLINK 31
|
||||
#define EPIPE 32
|
||||
#define EDOM 33
|
||||
#define ERANGE 34
|
||||
#define EDEADLK 35
|
||||
#define ENAMETOOLONG 36
|
||||
#define ENOLCK 37
|
||||
#define ENOSYS 38
|
||||
#define ENOTEMPTY 39
|
||||
|
||||
#endif
|
||||
@ -1,55 +0,0 @@
|
||||
#ifndef _FCNTL_H
|
||||
#define _FCNTL_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
/* open/fcntl - NOCTTY, NDELAY isn't implemented yet */
|
||||
#define O_ACCMODE 00003
|
||||
#define O_RDONLY 00
|
||||
#define O_WRONLY 01
|
||||
#define O_RDWR 02
|
||||
#define O_CREAT 00100 /* not fcntl */
|
||||
#define O_EXCL 00200 /* not fcntl */
|
||||
#define O_NOCTTY 00400 /* not fcntl */
|
||||
#define O_TRUNC 01000 /* not fcntl */
|
||||
#define O_APPEND 02000
|
||||
#define O_NONBLOCK 04000 /* not fcntl */
|
||||
#define O_NDELAY O_NONBLOCK
|
||||
|
||||
/* Defines for fcntl-commands. Note that currently
|
||||
* locking isn't supported, and other things aren't really
|
||||
* tested.
|
||||
*/
|
||||
#define F_DUPFD 0 /* dup */
|
||||
#define F_GETFD 1 /* get f_flags */
|
||||
#define F_SETFD 2 /* set f_flags */
|
||||
#define F_GETFL 3 /* more flags (cloexec) */
|
||||
#define F_SETFL 4
|
||||
#define F_GETLK 5 /* not implemented */
|
||||
#define F_SETLK 6
|
||||
#define F_SETLKW 7
|
||||
|
||||
/* for F_[GET|SET]FL */
|
||||
#define FD_CLOEXEC 1 /* actually anything with low bit set goes */
|
||||
|
||||
/* Ok, these are locking features, and aren't implemented at any
|
||||
* level. POSIX wants them.
|
||||
*/
|
||||
#define F_RDLCK 0
|
||||
#define F_WRLCK 1
|
||||
#define F_UNLCK 2
|
||||
|
||||
/* Once again - not implemented, but ... */
|
||||
struct flock {
|
||||
short l_type;
|
||||
short l_whence;
|
||||
off_t l_start;
|
||||
off_t l_len;
|
||||
pid_t l_pid;
|
||||
};
|
||||
|
||||
extern int creat(const char * filename,mode_t mode);
|
||||
extern int fcntl(int fildes,int cmd, ...);
|
||||
extern int open(const char * filename, int flags, ...);
|
||||
|
||||
#endif
|
||||
@ -1,48 +0,0 @@
|
||||
#ifndef _CONFIG_H
|
||||
#define _CONFIG_H
|
||||
|
||||
/*
|
||||
* The root-device is no longer hard-coded. You can change the default
|
||||
* root-device by changing the line ROOT_DEV = XXX in boot/bootsect.s
|
||||
*/
|
||||
|
||||
/*
|
||||
* define your keyboard here -
|
||||
* KBD_FINNISH for Finnish keyboards
|
||||
* KBD_US for US-type
|
||||
* KBD_GR for German keyboards
|
||||
* KBD_FR for Frech keyboard
|
||||
*/
|
||||
#define KBD_US
|
||||
/*#define KBD_GR */
|
||||
/*#define KBD_FR */
|
||||
/*#define KBD_FINNISH */
|
||||
|
||||
/*
|
||||
* Normally, Linux can get the drive parameters from the BIOS at
|
||||
* startup, but if this for some unfathomable reason fails, you'd
|
||||
* be left stranded. For this case, you can define HD_TYPE, which
|
||||
* contains all necessary info on your harddisk.
|
||||
*
|
||||
* The HD_TYPE macro should look like this:
|
||||
*
|
||||
* #define HD_TYPE { head, sect, cyl, wpcom, lzone, ctl}
|
||||
*
|
||||
* In case of two harddisks, the info should be sepatated by
|
||||
* commas:
|
||||
*
|
||||
* #define HD_TYPE { h,s,c,wpcom,lz,ctl },{ h,s,c,wpcom,lz,ctl }
|
||||
*/
|
||||
/*
|
||||
This is an example, two drives, first is type 2, second is type 3:
|
||||
|
||||
#define HD_TYPE { 4,17,615,300,615,8 }, { 6,17,615,300,615,0 }
|
||||
|
||||
NOTE: ctl is 0 for all drives with heads<=8, and ctl=8 for drives
|
||||
with more than 8 heads.
|
||||
|
||||
If you want the BIOS to tell what kind of drive you have, just
|
||||
leave HD_TYPE undefined. This is the normal thing to do.
|
||||
*/
|
||||
|
||||
#endif
|
||||
@ -1,71 +0,0 @@
|
||||
/*
|
||||
* This file contains some defines for the floppy disk controller.
|
||||
* Various sources. Mostly "IBM Microcomputers: A Programmers
|
||||
* Handbook", Sanches and Canton.
|
||||
*/
|
||||
#ifndef _FDREG_H
|
||||
#define _FDREG_H
|
||||
|
||||
extern int ticks_to_floppy_on(unsigned int nr);
|
||||
extern void floppy_on(unsigned int nr);
|
||||
extern void floppy_off(unsigned int nr);
|
||||
extern void floppy_select(unsigned int nr);
|
||||
extern void floppy_deselect(unsigned int nr);
|
||||
|
||||
/* Fd controller regs. S&C, about page 340 */
|
||||
#define FD_STATUS 0x3f4
|
||||
#define FD_DATA 0x3f5
|
||||
#define FD_DOR 0x3f2 /* Digital Output Register */
|
||||
#define FD_DIR 0x3f7 /* Digital Input Register (read) */
|
||||
#define FD_DCR 0x3f7 /* Diskette Control Register (write)*/
|
||||
|
||||
/* Bits of main status register */
|
||||
#define STATUS_BUSYMASK 0x0F /* drive busy mask */
|
||||
#define STATUS_BUSY 0x10 /* FDC busy */
|
||||
#define STATUS_DMA 0x20 /* 0- DMA mode */
|
||||
#define STATUS_DIR 0x40 /* 0- cpu->fdc */
|
||||
#define STATUS_READY 0x80 /* Data reg ready */
|
||||
|
||||
/* Bits of FD_ST0 */
|
||||
#define ST0_DS 0x03 /* drive select mask */
|
||||
#define ST0_HA 0x04 /* Head (Address) */
|
||||
#define ST0_NR 0x08 /* Not Ready */
|
||||
#define ST0_ECE 0x10 /* Equipment chech error */
|
||||
#define ST0_SE 0x20 /* Seek end */
|
||||
#define ST0_INTR 0xC0 /* Interrupt code mask */
|
||||
|
||||
/* Bits of FD_ST1 */
|
||||
#define ST1_MAM 0x01 /* Missing Address Mark */
|
||||
#define ST1_WP 0x02 /* Write Protect */
|
||||
#define ST1_ND 0x04 /* No Data - unreadable */
|
||||
#define ST1_OR 0x10 /* OverRun */
|
||||
#define ST1_CRC 0x20 /* CRC error in data or addr */
|
||||
#define ST1_EOC 0x80 /* End Of Cylinder */
|
||||
|
||||
/* Bits of FD_ST2 */
|
||||
#define ST2_MAM 0x01 /* Missing Addess Mark (again) */
|
||||
#define ST2_BC 0x02 /* Bad Cylinder */
|
||||
#define ST2_SNS 0x04 /* Scan Not Satisfied */
|
||||
#define ST2_SEH 0x08 /* Scan Equal Hit */
|
||||
#define ST2_WC 0x10 /* Wrong Cylinder */
|
||||
#define ST2_CRC 0x20 /* CRC error in data field */
|
||||
#define ST2_CM 0x40 /* Control Mark = deleted */
|
||||
|
||||
/* Bits of FD_ST3 */
|
||||
#define ST3_HA 0x04 /* Head (Address) */
|
||||
#define ST3_TZ 0x10 /* Track Zero signal (1=track 0) */
|
||||
#define ST3_WP 0x40 /* Write Protect */
|
||||
|
||||
/* Values for FD_COMMAND */
|
||||
#define FD_RECALIBRATE 0x07 /* move to track 0 */
|
||||
#define FD_SEEK 0x0F /* seek track */
|
||||
#define FD_READ 0xE6 /* read with MT, MFM, SKip deleted */
|
||||
#define FD_WRITE 0xC5 /* write with MT, MFM */
|
||||
#define FD_SENSEI 0x08 /* Sense Interrupt Status */
|
||||
#define FD_SPECIFY 0x03 /* specify HUT etc */
|
||||
|
||||
/* DMA commands */
|
||||
#define DMA_READ 0x46
|
||||
#define DMA_WRITE 0x4A
|
||||
|
||||
#endif
|
||||
@ -1,207 +0,0 @@
|
||||
/*
|
||||
* This file has definitions for some important file table
|
||||
* structures etc.
|
||||
*/
|
||||
|
||||
#ifndef _FS_H
|
||||
#define _FS_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
/* devices are as follows: (same as minix, so we can use the minix
|
||||
* file system. These are major numbers.)
|
||||
*
|
||||
* 0 - unused (nodev)
|
||||
* 1 - /dev/mem
|
||||
* 2 - /dev/fd
|
||||
* 3 - /dev/hd
|
||||
* 4 - /dev/ttyx
|
||||
* 5 - /dev/tty
|
||||
* 6 - /dev/lp
|
||||
* 7 - unnamed pipes
|
||||
*/
|
||||
|
||||
#define IS_SEEKABLE(x) ((x)>=1 && (x)<=3)
|
||||
|
||||
#define READ 0
|
||||
#define WRITE 1
|
||||
#define READA 2 /* read-ahead - don't pause */
|
||||
#define WRITEA 3 /* "write-ahead" - silly, but somewhat useful */
|
||||
|
||||
void buffer_init(long buffer_end);
|
||||
|
||||
#define MAJOR(a) (((unsigned)(a))>>8)
|
||||
#define MINOR(a) ((a)&0xff)
|
||||
|
||||
#define NAME_LEN 14
|
||||
#define ROOT_INO 1
|
||||
|
||||
#define I_MAP_SLOTS 8
|
||||
#define Z_MAP_SLOTS 8
|
||||
#define SUPER_MAGIC 0x137F
|
||||
|
||||
#define NR_OPEN 20
|
||||
#define NR_INODE 32
|
||||
#define NR_FILE 64
|
||||
#define NR_SUPER 8
|
||||
#define NR_HASH 307
|
||||
#define NR_BUFFERS nr_buffers
|
||||
#define BLOCK_SIZE 1024
|
||||
#define BLOCK_SIZE_BITS 10
|
||||
#ifndef NULL
|
||||
#define NULL ((void *) 0)
|
||||
#endif
|
||||
|
||||
#define INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct d_inode)))
|
||||
#define DIR_ENTRIES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct dir_entry)))
|
||||
|
||||
#define PIPE_HEAD(inode) ((inode).i_zone[0])
|
||||
#define PIPE_TAIL(inode) ((inode).i_zone[1])
|
||||
#define PIPE_SIZE(inode) ((PIPE_HEAD(inode)-PIPE_TAIL(inode))&(PAGE_SIZE-1))
|
||||
#define PIPE_EMPTY(inode) (PIPE_HEAD(inode)==PIPE_TAIL(inode))
|
||||
#define PIPE_FULL(inode) (PIPE_SIZE(inode)==(PAGE_SIZE-1))
|
||||
#define INC_PIPE(head) \
|
||||
__asm__("incl %0\n\tandl $4095,%0"::"m" (head))
|
||||
|
||||
typedef char buffer_block[BLOCK_SIZE];
|
||||
|
||||
struct buffer_head {
|
||||
char * b_data; /* pointer to data block (1024 bytes) */
|
||||
unsigned long b_blocknr; /* block number */
|
||||
unsigned short b_dev; /* device (0 = free) */
|
||||
unsigned char b_uptodate;
|
||||
unsigned char b_dirt; /* 0-clean,1-dirty */
|
||||
unsigned char b_count; /* users using this block */
|
||||
unsigned char b_lock; /* 0 - ok, 1 -locked */
|
||||
struct task_struct * b_wait;
|
||||
struct buffer_head * b_prev;
|
||||
struct buffer_head * b_next;
|
||||
struct buffer_head * b_prev_free;
|
||||
struct buffer_head * b_next_free;
|
||||
};
|
||||
|
||||
struct d_inode {
|
||||
unsigned short i_mode;
|
||||
unsigned short i_uid;
|
||||
unsigned long i_size;
|
||||
unsigned long i_time;
|
||||
unsigned char i_gid;
|
||||
unsigned char i_nlinks;
|
||||
unsigned short i_zone[9];
|
||||
};
|
||||
|
||||
struct m_inode {
|
||||
unsigned short i_mode;
|
||||
unsigned short i_uid;
|
||||
unsigned long i_size;
|
||||
unsigned long i_mtime;
|
||||
unsigned char i_gid;
|
||||
unsigned char i_nlinks;
|
||||
unsigned short i_zone[9];
|
||||
/* these are in memory also */
|
||||
struct task_struct * i_wait;
|
||||
unsigned long i_atime;
|
||||
unsigned long i_ctime;
|
||||
unsigned short i_dev;
|
||||
unsigned short i_num;
|
||||
unsigned short i_count;
|
||||
unsigned char i_lock;
|
||||
unsigned char i_dirt;
|
||||
unsigned char i_pipe;
|
||||
unsigned char i_mount;
|
||||
unsigned char i_seek;
|
||||
unsigned char i_update;
|
||||
};
|
||||
|
||||
struct file {
|
||||
unsigned short f_mode;
|
||||
unsigned short f_flags;
|
||||
unsigned short f_count;
|
||||
struct m_inode * f_inode;
|
||||
off_t f_pos;
|
||||
};
|
||||
|
||||
struct super_block {
|
||||
unsigned short s_ninodes;
|
||||
unsigned short s_nzones;
|
||||
unsigned short s_imap_blocks;
|
||||
unsigned short s_zmap_blocks;
|
||||
unsigned short s_firstdatazone;
|
||||
unsigned short s_log_zone_size;
|
||||
unsigned long s_max_size;
|
||||
unsigned short s_magic;
|
||||
/* These are only in memory */
|
||||
struct buffer_head * s_imap[8];
|
||||
struct buffer_head * s_zmap[8];
|
||||
unsigned short s_dev;
|
||||
struct m_inode * s_isup;
|
||||
struct m_inode * s_imount;
|
||||
unsigned long s_time;
|
||||
struct task_struct * s_wait;
|
||||
unsigned char s_lock;
|
||||
unsigned char s_rd_only;
|
||||
unsigned char s_dirt;
|
||||
};
|
||||
struct linux_dirent{
|
||||
long d_ino;
|
||||
off_t d_off;
|
||||
unsigned short d_reclen;
|
||||
char d_name[NAME_LEN];
|
||||
};
|
||||
struct d_super_block {
|
||||
unsigned short s_ninodes;
|
||||
unsigned short s_nzones;
|
||||
unsigned short s_imap_blocks;
|
||||
unsigned short s_zmap_blocks;
|
||||
unsigned short s_firstdatazone;
|
||||
unsigned short s_log_zone_size;
|
||||
unsigned long s_max_size;
|
||||
unsigned short s_magic;
|
||||
};
|
||||
|
||||
struct dir_entry {
|
||||
unsigned short inode;
|
||||
char name[NAME_LEN];
|
||||
};
|
||||
|
||||
extern struct m_inode inode_table[NR_INODE];
|
||||
extern struct file file_table[NR_FILE];
|
||||
extern struct super_block super_block[NR_SUPER];
|
||||
extern struct buffer_head * start_buffer;
|
||||
extern int nr_buffers;
|
||||
|
||||
extern void check_disk_change(int dev);
|
||||
extern int floppy_change(unsigned int nr);
|
||||
extern int ticks_to_floppy_on(unsigned int dev);
|
||||
extern void floppy_on(unsigned int dev);
|
||||
extern void floppy_off(unsigned int dev);
|
||||
extern void truncate(struct m_inode * inode);
|
||||
extern void sync_inodes(void);
|
||||
extern void wait_on(struct m_inode * inode);
|
||||
extern int bmap(struct m_inode * inode,int block);
|
||||
extern int create_block(struct m_inode * inode,int block);
|
||||
extern struct m_inode * namei(const char * pathname);
|
||||
extern int open_namei(const char * pathname, int flag, int mode,
|
||||
struct m_inode ** res_inode);
|
||||
extern void iput(struct m_inode * inode);
|
||||
extern struct m_inode * iget(int dev,int nr);
|
||||
extern struct m_inode * get_empty_inode(void);
|
||||
extern struct m_inode * get_pipe_inode(void);
|
||||
extern struct buffer_head * get_hash_table(int dev, int block);
|
||||
extern struct buffer_head * getblk(int dev, int block);
|
||||
extern void ll_rw_block(int rw, struct buffer_head * bh);
|
||||
extern void brelse(struct buffer_head * buf);
|
||||
extern struct buffer_head * bread(int dev,int block);
|
||||
extern void bread_page(unsigned long addr,int dev,int b[4]);
|
||||
extern struct buffer_head * breada(int dev,int block,...);
|
||||
extern int new_block(int dev);
|
||||
extern void free_block(int dev, int block);
|
||||
extern struct m_inode * new_inode(int dev);
|
||||
extern void free_inode(struct m_inode * inode);
|
||||
extern int sync_dev(int dev);
|
||||
extern struct super_block * get_super(int dev);
|
||||
extern int ROOT_DEV;
|
||||
|
||||
extern void mount_root(void);
|
||||
|
||||
#endif
|
||||
@ -1,65 +0,0 @@
|
||||
/*
|
||||
* This file contains some defines for the AT-hd-controller.
|
||||
* Various sources. Check out some definitions (see comments with
|
||||
* a ques).
|
||||
*/
|
||||
#ifndef _HDREG_H
|
||||
#define _HDREG_H
|
||||
|
||||
/* Hd controller regs. Ref: IBM AT Bios-listing */
|
||||
#define HD_DATA 0x1f0 /* _CTL when writing */
|
||||
#define HD_ERROR 0x1f1 /* see err-bits */
|
||||
#define HD_NSECTOR 0x1f2 /* nr of sectors to read/write */
|
||||
#define HD_SECTOR 0x1f3 /* starting sector */
|
||||
#define HD_LCYL 0x1f4 /* starting cylinder */
|
||||
#define HD_HCYL 0x1f5 /* high byte of starting cyl */
|
||||
#define HD_CURRENT 0x1f6 /* 101dhhhh , d=drive, hhhh=head */
|
||||
#define HD_STATUS 0x1f7 /* see status-bits */
|
||||
#define HD_PRECOMP HD_ERROR /* same io address, read=error, write=precomp */
|
||||
#define HD_COMMAND HD_STATUS /* same io address, read=status, write=cmd */
|
||||
|
||||
#define HD_CMD 0x3f6
|
||||
|
||||
/* Bits of HD_STATUS */
|
||||
#define ERR_STAT 0x01
|
||||
#define INDEX_STAT 0x02
|
||||
#define ECC_STAT 0x04 /* Corrected error */
|
||||
#define DRQ_STAT 0x08
|
||||
#define SEEK_STAT 0x10
|
||||
#define WRERR_STAT 0x20
|
||||
#define READY_STAT 0x40
|
||||
#define BUSY_STAT 0x80
|
||||
|
||||
/* Values for HD_COMMAND */
|
||||
#define WIN_RESTORE 0x10
|
||||
#define WIN_READ 0x20
|
||||
#define WIN_WRITE 0x30
|
||||
#define WIN_VERIFY 0x40
|
||||
#define WIN_FORMAT 0x50
|
||||
#define WIN_INIT 0x60
|
||||
#define WIN_SEEK 0x70
|
||||
#define WIN_DIAGNOSE 0x90
|
||||
#define WIN_SPECIFY 0x91
|
||||
|
||||
/* Bits for HD_ERROR */
|
||||
#define MARK_ERR 0x01 /* Bad address mark ? */
|
||||
#define TRK0_ERR 0x02 /* couldn't find track 0 */
|
||||
#define ABRT_ERR 0x04 /* ? */
|
||||
#define ID_ERR 0x10 /* ? */
|
||||
#define ECC_ERR 0x40 /* ? */
|
||||
#define BBD_ERR 0x80 /* ? */
|
||||
|
||||
struct partition {
|
||||
unsigned char boot_ind; /* 0x80 - active (unused) */
|
||||
unsigned char head; /* ? */
|
||||
unsigned char sector; /* ? */
|
||||
unsigned char cyl; /* ? */
|
||||
unsigned char sys_ind; /* ? */
|
||||
unsigned char end_head; /* ? */
|
||||
unsigned char end_sector; /* ? */
|
||||
unsigned char end_cyl; /* ? */
|
||||
unsigned int start_sect; /* starting sector counting from 0 */
|
||||
unsigned int nr_sects; /* nr of sectors in partition */
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -1,20 +0,0 @@
|
||||
#ifndef _HEAD_H
|
||||
#define _HEAD_H
|
||||
|
||||
typedef struct desc_struct {
|
||||
unsigned long a,b;
|
||||
} desc_table[256];
|
||||
|
||||
extern unsigned long pg_dir[1024];
|
||||
extern desc_table idt,gdt;
|
||||
|
||||
#define GDT_NUL 0
|
||||
#define GDT_CODE 1
|
||||
#define GDT_DATA 2
|
||||
#define GDT_TMP 3
|
||||
|
||||
#define LDT_NUL 0
|
||||
#define LDT_CODE 1
|
||||
#define LDT_DATA 2
|
||||
|
||||
#endif
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* 'kernel.h' contains some often-used function prototypes etc
|
||||
*/
|
||||
void verify_area(void * addr,int count);
|
||||
volatile void panic(const char * str);
|
||||
int printf(const char * fmt, ...);
|
||||
int printk(const char * fmt, ...);
|
||||
int tty_write(unsigned ch,char * buf,int count);
|
||||
void * malloc(unsigned int size);
|
||||
void free_s(void * obj, int size);
|
||||
|
||||
#define free(x) free_s((x), 0)
|
||||
|
||||
/*
|
||||
* This is defined as a macro, but at some point this might become a
|
||||
* real subroutine that sets a flag if it returns true (to do
|
||||
* BSD-style accounting where the process is flagged if it uses root
|
||||
* privs). The implication of this is that you should do normal
|
||||
* permissions checks first, and check suser() last.
|
||||
*/
|
||||
#define suser() (current->euid == 0)
|
||||
|
||||
@ -1,10 +0,0 @@
|
||||
#ifndef _MM_H
|
||||
#define _MM_H
|
||||
|
||||
#define PAGE_SIZE 4096
|
||||
|
||||
extern unsigned long get_free_page(void);
|
||||
extern unsigned long put_page(unsigned long page,unsigned long address);
|
||||
extern void free_page(unsigned long addr);
|
||||
|
||||
#endif
|
||||
@ -1,239 +0,0 @@
|
||||
#ifndef _SCHED_H
|
||||
#define _SCHED_H
|
||||
|
||||
#define NR_TASKS 64
|
||||
#define HZ 100
|
||||
|
||||
#define FIRST_TASK task[0]
|
||||
#define LAST_TASK task[NR_TASKS-1]
|
||||
|
||||
#include <linux/head.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/mm.h>
|
||||
#include <signal.h>
|
||||
|
||||
#if (NR_OPEN > 32)
|
||||
#error "Currently the close-on-exec-flags are in one word, max 32 files/proc"
|
||||
#endif
|
||||
|
||||
#define TASK_RUNNING 0
|
||||
#define TASK_INTERRUPTIBLE 1
|
||||
#define TASK_UNINTERRUPTIBLE 2
|
||||
#define TASK_ZOMBIE 3
|
||||
#define TASK_STOPPED 4
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL ((void *) 0)
|
||||
#endif
|
||||
|
||||
extern int copy_page_tables(unsigned long from, unsigned long to, long size);
|
||||
extern int free_page_tables(unsigned long from, unsigned long size);
|
||||
|
||||
extern void sched_init(void);
|
||||
extern void schedule(void);
|
||||
extern void trap_init(void);
|
||||
extern void panic(const char * str);
|
||||
extern int tty_write(unsigned minor,char * buf,int count);
|
||||
|
||||
typedef int (*fn_ptr)();
|
||||
|
||||
struct i387_struct {
|
||||
long cwd;
|
||||
long swd;
|
||||
long twd;
|
||||
long fip;
|
||||
long fcs;
|
||||
long foo;
|
||||
long fos;
|
||||
long st_space[20]; /* 8*10 bytes for each FP-reg = 80 bytes */
|
||||
};
|
||||
|
||||
struct tss_struct {
|
||||
long back_link; /* 16 high bits zero */
|
||||
long esp0;
|
||||
long ss0; /* 16 high bits zero */
|
||||
long esp1;
|
||||
long ss1; /* 16 high bits zero */
|
||||
long esp2;
|
||||
long ss2; /* 16 high bits zero */
|
||||
long cr3;
|
||||
long eip;
|
||||
long eflags;
|
||||
long eax,ecx,edx,ebx;
|
||||
long esp;
|
||||
long ebp;
|
||||
long esi;
|
||||
long edi;
|
||||
long es; /* 16 high bits zero */
|
||||
long cs; /* 16 high bits zero */
|
||||
long ss; /* 16 high bits zero */
|
||||
long ds; /* 16 high bits zero */
|
||||
long fs; /* 16 high bits zero */
|
||||
long gs; /* 16 high bits zero */
|
||||
long ldt; /* 16 high bits zero */
|
||||
long trace_bitmap; /* bits: trace 0, bitmap 16-31 */
|
||||
struct i387_struct i387;
|
||||
};
|
||||
|
||||
struct task_struct {
|
||||
/* these are hardcoded - don't touch */
|
||||
long state; /* -1 unrunnable, 0 runnable, >0 stopped */
|
||||
long counter;
|
||||
long priority;
|
||||
long signal;
|
||||
struct sigaction sigaction[32];
|
||||
long blocked; /* bitmap of masked signals */
|
||||
/* various fields */
|
||||
int exit_code;
|
||||
unsigned long start_code,end_code,end_data,brk,start_stack;
|
||||
long pid,father,pgrp,session,leader;
|
||||
unsigned short uid,euid,suid;
|
||||
unsigned short gid,egid,sgid;
|
||||
long alarm;
|
||||
long utime,stime,cutime,cstime,start_time;
|
||||
unsigned short used_math;
|
||||
/* file system info */
|
||||
int tty; /* -1 if no tty, so it must be signed */
|
||||
unsigned short umask;
|
||||
struct m_inode * pwd;
|
||||
struct m_inode * root;
|
||||
struct m_inode * executable;
|
||||
unsigned long close_on_exec;
|
||||
struct file * filp[NR_OPEN];
|
||||
/* ldt for this task 0 - zero 1 - cs 2 - ds&ss */
|
||||
struct desc_struct ldt[3];
|
||||
/* tss for this task */
|
||||
struct tss_struct tss;
|
||||
};
|
||||
|
||||
/*
|
||||
* INIT_TASK is used to set up the first task table, touch at
|
||||
* your own risk!. Base=0, limit=0x9ffff (=640kB)
|
||||
*/
|
||||
#define INIT_TASK \
|
||||
/* state etc */ { 0,15,15, \
|
||||
/* signals */ 0,{{},},0, \
|
||||
/* ec,brk... */ 0,0,0,0,0,0, \
|
||||
/* pid etc.. */ 0,-1,0,0,0, \
|
||||
/* uid etc */ 0,0,0,0,0,0, \
|
||||
/* alarm */ 0,0,0,0,0,0, \
|
||||
/* math */ 0, \
|
||||
/* fs info */ -1,0022,NULL,NULL,NULL,0, \
|
||||
/* filp */ {NULL,}, \
|
||||
{ \
|
||||
{0,0}, \
|
||||
/* ldt */ {0x9f,0xc0fa00}, \
|
||||
{0x9f,0xc0f200}, \
|
||||
}, \
|
||||
/*tss*/ {0,PAGE_SIZE+(long)&init_task,0x10,0,0,0,0,(long)&pg_dir,\
|
||||
0,0,0,0,0,0,0,0, \
|
||||
0,0,0x17,0x17,0x17,0x17,0x17,0x17, \
|
||||
_LDT(0),0x80000000, \
|
||||
{} \
|
||||
}, \
|
||||
}
|
||||
|
||||
extern struct task_struct *task[NR_TASKS];
|
||||
extern struct task_struct *last_task_used_math;
|
||||
extern struct task_struct *current;
|
||||
extern long volatile jiffies;
|
||||
extern long startup_time;
|
||||
|
||||
#define CURRENT_TIME (startup_time+jiffies/HZ)
|
||||
|
||||
extern void add_timer(long jiffies, void (*fn)(void));
|
||||
extern void sleep_on(struct task_struct ** p);
|
||||
extern void interruptible_sleep_on(struct task_struct ** p);
|
||||
extern void wake_up(struct task_struct ** p);
|
||||
|
||||
/*
|
||||
* Entry into gdt where to find first TSS. 0-nul, 1-cs, 2-ds, 3-syscall
|
||||
* 4-TSS0, 5-LDT0, 6-TSS1 etc ...
|
||||
*/
|
||||
#define FIRST_TSS_ENTRY 4
|
||||
#define FIRST_LDT_ENTRY (FIRST_TSS_ENTRY+1)
|
||||
#define _TSS(n) ((((unsigned long) n)<<4)+(FIRST_TSS_ENTRY<<3))
|
||||
#define _LDT(n) ((((unsigned long) n)<<4)+(FIRST_LDT_ENTRY<<3))
|
||||
#define ltr(n) __asm__("ltr %%ax"::"a" (_TSS(n)))
|
||||
#define lldt(n) __asm__("lldt %%ax"::"a" (_LDT(n)))
|
||||
#define str(n) \
|
||||
__asm__("str %%ax\n\t" \
|
||||
"subl %2,%%eax\n\t" \
|
||||
"shrl $4,%%eax" \
|
||||
:"=a" (n) \
|
||||
:"a" (0),"i" (FIRST_TSS_ENTRY<<3))
|
||||
/*
|
||||
* switch_to(n) should switch tasks to task nr n, first
|
||||
* checking that n isn't the current task, in which case it does nothing.
|
||||
* This also clears the TS-flag if the task we switched to has used
|
||||
* tha math co-processor latest.
|
||||
*/
|
||||
#define switch_to(n) {\
|
||||
struct {long a,b;} __tmp; \
|
||||
__asm__("cmpl %%ecx,current\n\t" \
|
||||
"je 1f\n\t" \
|
||||
"movw %%dx,%1\n\t" \
|
||||
"xchgl %%ecx,current\n\t" \
|
||||
"ljmp *%0\n\t" \
|
||||
"cmpl %%ecx,last_task_used_math\n\t" \
|
||||
"jne 1f\n\t" \
|
||||
"clts\n" \
|
||||
"1:" \
|
||||
::"m" (*&__tmp.a),"m" (*&__tmp.b), \
|
||||
"d" (_TSS(n)),"c" ((long) task[n])); \
|
||||
}
|
||||
|
||||
#define PAGE_ALIGN(n) (((n)+0xfff)&0xfffff000)
|
||||
|
||||
#define _set_base(addr,base) \
|
||||
__asm__ ("push %%edx\n\t" \
|
||||
"movw %%dx,%0\n\t" \
|
||||
"rorl $16,%%edx\n\t" \
|
||||
"movb %%dl,%1\n\t" \
|
||||
"movb %%dh,%2\n\t" \
|
||||
"pop %%edx" \
|
||||
::"m" (*((addr)+2)), \
|
||||
"m" (*((addr)+4)), \
|
||||
"m" (*((addr)+7)), \
|
||||
"d" (base) \
|
||||
)
|
||||
|
||||
#define _set_limit(addr,limit) \
|
||||
__asm__ ("push %%edx\n\t" \
|
||||
"movw %%dx,%0\n\t" \
|
||||
"rorl $16,%%edx\n\t" \
|
||||
"movb %1,%%dh\n\t" \
|
||||
"andb $0xf0,%%dh\n\t" \
|
||||
"orb %%dh,%%dl\n\t" \
|
||||
"movb %%dl,%1\n\t" \
|
||||
"pop %%edx" \
|
||||
::"m" (*(addr)), \
|
||||
"m" (*((addr)+6)), \
|
||||
"d" (limit) \
|
||||
)
|
||||
|
||||
#define set_base(ldt,base) _set_base( ((char *)&(ldt)) , (base) )
|
||||
#define set_limit(ldt,limit) _set_limit( ((char *)&(ldt)) , (limit-1)>>12 )
|
||||
|
||||
static inline unsigned long _get_base(char * addr)
|
||||
{
|
||||
unsigned long __base;
|
||||
__asm__("movb %3,%%dh\n\t"
|
||||
"movb %2,%%dl\n\t"
|
||||
"shll $16,%%edx\n\t"
|
||||
"movw %1,%%dx"
|
||||
:"=&d" (__base)
|
||||
:"m" (*((addr)+2)),
|
||||
"m" (*((addr)+4)),
|
||||
"m" (*((addr)+7)));
|
||||
return __base;
|
||||
}
|
||||
|
||||
#define get_base(ldt) _get_base( ((char *)&(ldt)) )
|
||||
|
||||
#define get_limit(segment) ({ \
|
||||
unsigned long __limit; \
|
||||
__asm__("lsll %1,%0\n\tincl %0":"=r" (__limit):"r" (segment)); \
|
||||
__limit;})
|
||||
|
||||
#endif
|
||||
@ -1,115 +0,0 @@
|
||||
/*
|
||||
* Why isn't this a .c file? Enquiring minds....
|
||||
*/
|
||||
|
||||
extern int sys_setup();
|
||||
extern int sys_exit();
|
||||
extern int sys_fork();
|
||||
extern int sys_read();
|
||||
extern int sys_write();
|
||||
extern int sys_open();
|
||||
extern int sys_close();
|
||||
extern int sys_waitpid();
|
||||
extern int sys_creat();
|
||||
extern int sys_link();
|
||||
extern int sys_unlink();
|
||||
extern int sys_execve();
|
||||
extern int sys_chdir();
|
||||
extern int sys_time();
|
||||
extern int sys_mknod();
|
||||
extern int sys_chmod();
|
||||
extern int sys_chown();
|
||||
extern int sys_break();
|
||||
extern int sys_stat();
|
||||
extern int sys_lseek();
|
||||
extern int sys_getpid();
|
||||
extern int sys_mount();
|
||||
extern int sys_umount();
|
||||
extern int sys_setuid();
|
||||
extern int sys_getuid();
|
||||
extern int sys_stime();
|
||||
extern int sys_ptrace();
|
||||
extern int sys_alarm();
|
||||
extern int sys_fstat();
|
||||
extern int sys_pause();
|
||||
extern int sys_utime();
|
||||
extern int sys_stty();
|
||||
extern int sys_gtty();
|
||||
extern int sys_access();
|
||||
extern int sys_nice();
|
||||
extern int sys_ftime();
|
||||
extern int sys_sync();
|
||||
extern int sys_kill();
|
||||
extern int sys_rename();
|
||||
extern int sys_mkdir();
|
||||
extern int sys_rmdir();
|
||||
extern int sys_dup();
|
||||
extern int sys_pipe();
|
||||
extern int sys_times();
|
||||
extern int sys_prof();
|
||||
extern int sys_brk();
|
||||
extern int sys_setgid();
|
||||
extern int sys_getgid();
|
||||
extern int sys_signal();
|
||||
extern int sys_geteuid();
|
||||
extern int sys_getegid();
|
||||
extern int sys_acct();
|
||||
extern int sys_phys();
|
||||
extern int sys_lock();
|
||||
extern int sys_ioctl();
|
||||
extern int sys_fcntl();
|
||||
extern int sys_mpx();
|
||||
extern int sys_setpgid();
|
||||
extern int sys_ulimit();
|
||||
extern int sys_uname();
|
||||
extern int sys_umask();
|
||||
extern int sys_chroot();
|
||||
extern int sys_ustat();
|
||||
extern int sys_dup2();
|
||||
extern int sys_getppid();
|
||||
extern int sys_getpgrp();
|
||||
extern int sys_setsid();
|
||||
extern int sys_sigaction();
|
||||
extern int sys_sgetmask();
|
||||
extern int sys_ssetmask();
|
||||
extern int sys_setreuid();
|
||||
extern int sys_setregid();
|
||||
extern int sys_sigpending();
|
||||
extern int sys_sigsuspend();
|
||||
extern int sys_sethostname();
|
||||
extern int sys_setrlimit();
|
||||
extern int sys_getrlimit();
|
||||
extern int sys_getrusage();
|
||||
extern int sys_gettimeofday();
|
||||
extern int sys_settimeofday();
|
||||
extern int sys_getgroups();
|
||||
extern int sys_setgroups();
|
||||
extern int sys_select();
|
||||
extern int sys_symlink();
|
||||
extern int sys_lstat();
|
||||
extern int sys_readlink();
|
||||
extern int sys_uselib();
|
||||
extern int sys_execve2();
|
||||
extern int sys_getdents();
|
||||
extern int sys_getpipe2();
|
||||
extern long sys_getcwd();
|
||||
extern int sys_sleep();
|
||||
fn_ptr sys_call_table[] = { sys_setup, sys_exit, sys_fork, sys_read,
|
||||
sys_write, sys_open, sys_close, sys_waitpid, sys_creat, sys_link,
|
||||
sys_unlink, sys_execve, sys_chdir, sys_time, sys_mknod, sys_chmod,
|
||||
sys_chown, sys_break, sys_stat, sys_lseek, sys_getpid, sys_mount,
|
||||
sys_umount, sys_setuid, sys_getuid, sys_stime, sys_ptrace, sys_alarm,
|
||||
sys_fstat, sys_pause, sys_utime, sys_stty, sys_gtty, sys_access,
|
||||
sys_nice, sys_ftime, sys_sync, sys_kill, sys_rename, sys_mkdir,
|
||||
sys_rmdir, sys_dup, sys_pipe, sys_times, sys_prof, sys_brk, sys_setgid,
|
||||
sys_getgid, sys_signal, sys_geteuid, sys_getegid, sys_acct, sys_phys,
|
||||
sys_lock, sys_ioctl, sys_fcntl, sys_mpx, sys_setpgid, sys_ulimit,
|
||||
sys_uname, sys_umask, sys_chroot, sys_ustat, sys_dup2, sys_getppid,
|
||||
sys_getpgrp, sys_setsid, sys_sigaction, sys_sgetmask, sys_ssetmask,
|
||||
sys_setreuid,sys_setregid, sys_sigsuspend, sys_sigpending, sys_sethostname,
|
||||
sys_setrlimit, sys_getrlimit, sys_getrusage, sys_gettimeofday,
|
||||
sys_settimeofday, sys_getgroups, sys_setgroups, sys_select, sys_symlink,
|
||||
sys_lstat, sys_readlink, sys_uselib,sys_execve2,sys_getdents,sys_getpipe2,sys_sleep,sys_getcwd};
|
||||
|
||||
/* So we don't have to do any more manual updating.... */
|
||||
int NR_syscalls = sizeof(sys_call_table)/sizeof(fn_ptr);
|
||||
@ -1,77 +0,0 @@
|
||||
/*
|
||||
* 'tty.h' defines some structures used by tty_io.c and some defines.
|
||||
*
|
||||
* NOTE! Don't touch this without checking that nothing in rs_io.s or
|
||||
* con_io.s breaks. Some constants are hardwired into the system (mainly
|
||||
* offsets into 'tty_queue'
|
||||
*/
|
||||
|
||||
#ifndef _TTY_H
|
||||
#define _TTY_H
|
||||
|
||||
#include <termios.h>
|
||||
|
||||
#define TTY_BUF_SIZE 1024
|
||||
|
||||
struct tty_queue {
|
||||
unsigned long data;
|
||||
unsigned long head;
|
||||
unsigned long tail;
|
||||
struct task_struct * proc_list;
|
||||
char buf[TTY_BUF_SIZE];
|
||||
};
|
||||
|
||||
#define INC(a) ((a) = ((a)+1) & (TTY_BUF_SIZE-1))
|
||||
#define DEC(a) ((a) = ((a)-1) & (TTY_BUF_SIZE-1))
|
||||
#define EMPTY(a) ((a).head == (a).tail)
|
||||
#define LEFT(a) (((a).tail-(a).head-1)&(TTY_BUF_SIZE-1))
|
||||
#define LAST(a) ((a).buf[(TTY_BUF_SIZE-1)&((a).head-1)])
|
||||
#define FULL(a) (!LEFT(a))
|
||||
#define CHARS(a) (((a).head-(a).tail)&(TTY_BUF_SIZE-1))
|
||||
#define GETCH(queue,c) \
|
||||
(void)({c=(queue).buf[(queue).tail];INC((queue).tail);})
|
||||
#define PUTCH(c,queue) \
|
||||
(void)({(queue).buf[(queue).head]=(c);INC((queue).head);})
|
||||
|
||||
#define INTR_CHAR(tty) ((tty)->termios.c_cc[VINTR])
|
||||
#define QUIT_CHAR(tty) ((tty)->termios.c_cc[VQUIT])
|
||||
#define ERASE_CHAR(tty) ((tty)->termios.c_cc[VERASE])
|
||||
#define KILL_CHAR(tty) ((tty)->termios.c_cc[VKILL])
|
||||
#define EOF_CHAR(tty) ((tty)->termios.c_cc[VEOF])
|
||||
#define START_CHAR(tty) ((tty)->termios.c_cc[VSTART])
|
||||
#define STOP_CHAR(tty) ((tty)->termios.c_cc[VSTOP])
|
||||
#define SUSPEND_CHAR(tty) ((tty)->termios.c_cc[VSUSP])
|
||||
|
||||
struct tty_struct {
|
||||
struct termios termios;
|
||||
int pgrp;
|
||||
int stopped;
|
||||
void (*write)(struct tty_struct * tty);
|
||||
struct tty_queue read_q;
|
||||
struct tty_queue write_q;
|
||||
struct tty_queue secondary;
|
||||
};
|
||||
|
||||
extern struct tty_struct tty_table[];
|
||||
|
||||
/* intr=^C quit=^| erase=del kill=^U
|
||||
eof=^D vtime=\0 vmin=\1 sxtc=\0
|
||||
start=^Q stop=^S susp=^Z eol=\0
|
||||
reprint=^R discard=^U werase=^W lnext=^V
|
||||
eol2=\0
|
||||
*/
|
||||
#define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"
|
||||
|
||||
void rs_init(void);
|
||||
void con_init(void);
|
||||
void tty_init(void);
|
||||
|
||||
int tty_read(unsigned c, char * buf, int n);
|
||||
int tty_write(unsigned c, char * buf, int n);
|
||||
|
||||
void rs_write(struct tty_struct * tty);
|
||||
void con_write(struct tty_struct * tty);
|
||||
|
||||
void copy_to_cooked(struct tty_struct * tty);
|
||||
|
||||
#endif
|
||||
@ -1,68 +0,0 @@
|
||||
#ifndef _SIGNAL_H
|
||||
#define _SIGNAL_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
typedef int sig_atomic_t;
|
||||
typedef unsigned int sigset_t; /* 32 bits */
|
||||
|
||||
#define _NSIG 32
|
||||
#define NSIG _NSIG
|
||||
|
||||
#define SIGHUP 1
|
||||
#define SIGINT 2
|
||||
#define SIGQUIT 3
|
||||
#define SIGILL 4
|
||||
#define SIGTRAP 5
|
||||
#define SIGABRT 6
|
||||
#define SIGIOT 6
|
||||
#define SIGUNUSED 7
|
||||
#define SIGFPE 8
|
||||
#define SIGKILL 9
|
||||
#define SIGUSR1 10
|
||||
#define SIGSEGV 11
|
||||
#define SIGUSR2 12
|
||||
#define SIGPIPE 13
|
||||
#define SIGALRM 14
|
||||
#define SIGTERM 15
|
||||
#define SIGSTKFLT 16
|
||||
#define SIGCHLD 17
|
||||
#define SIGCONT 18
|
||||
#define SIGSTOP 19
|
||||
#define SIGTSTP 20
|
||||
#define SIGTTIN 21
|
||||
#define SIGTTOU 22
|
||||
|
||||
/* Ok, I haven't implemented sigactions, but trying to keep headers POSIX */
|
||||
#define SA_NOCLDSTOP 1
|
||||
#define SA_NOMASK 0x40000000
|
||||
#define SA_ONESHOT 0x80000000
|
||||
|
||||
#define SIG_BLOCK 0 /* for blocking signals */
|
||||
#define SIG_UNBLOCK 1 /* for unblocking signals */
|
||||
#define SIG_SETMASK 2 /* for setting the signal mask */
|
||||
|
||||
#define SIG_DFL ((void (*)(int))0) /* default signal handling */
|
||||
#define SIG_IGN ((void (*)(int))1) /* ignore signal */
|
||||
|
||||
struct sigaction {
|
||||
void (*sa_handler)(int);
|
||||
sigset_t sa_mask;
|
||||
int sa_flags;
|
||||
void (*sa_restorer)(void);
|
||||
};
|
||||
|
||||
void (*signal(int _sig, void (*_func)(int)))(int);
|
||||
int raise(int sig);
|
||||
int kill(pid_t pid, int sig);
|
||||
int sigaddset(sigset_t *mask, int signo);
|
||||
int sigdelset(sigset_t *mask, int signo);
|
||||
int sigemptyset(sigset_t *mask);
|
||||
int sigfillset(sigset_t *mask);
|
||||
int sigismember(sigset_t *mask, int signo); /* 1 - is, 0 - not, -1 error */
|
||||
int sigpending(sigset_t *set);
|
||||
int sigprocmask(int how, sigset_t *set, sigset_t *oldset);
|
||||
int sigsuspend(sigset_t *sigmask);
|
||||
int sigaction(int sig, struct sigaction *act, struct sigaction *oldact);
|
||||
|
||||
#endif /* _SIGNAL_H */
|
||||
@ -1,28 +0,0 @@
|
||||
#ifndef _STDARG_H
|
||||
#define _STDARG_H
|
||||
|
||||
typedef char *va_list;
|
||||
|
||||
/* Amount of space required in an argument list for an arg of type TYPE.
|
||||
TYPE may alternatively be an expression whose type is used. */
|
||||
|
||||
#define __va_rounded_size(TYPE) \
|
||||
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
|
||||
|
||||
#ifndef __sparc__
|
||||
#define va_start(AP, LASTARG) \
|
||||
(AP = ((char *) &(LASTARG) + __va_rounded_size (LASTARG)))
|
||||
#else
|
||||
#define va_start(AP, LASTARG) \
|
||||
(__builtin_saveregs (), \
|
||||
AP = ((char *) &(LASTARG) + __va_rounded_size (LASTARG)))
|
||||
#endif
|
||||
|
||||
void va_end (va_list); /* Defined in gnulib */
|
||||
#define va_end(AP)
|
||||
|
||||
#define va_arg(AP, TYPE) \
|
||||
(AP += __va_rounded_size (TYPE), \
|
||||
*((TYPE *) (AP - __va_rounded_size (TYPE))))
|
||||
|
||||
#endif /* _STDARG_H */
|
||||
@ -1,19 +0,0 @@
|
||||
#ifndef _STDDEF_H
|
||||
#define _STDDEF_H
|
||||
|
||||
#ifndef _PTRDIFF_T
|
||||
#define _PTRDIFF_T
|
||||
typedef long ptrdiff_t;
|
||||
#endif
|
||||
|
||||
#ifndef _SIZE_T
|
||||
#define _SIZE_T
|
||||
typedef unsigned long size_t;
|
||||
#endif
|
||||
|
||||
#undef NULL
|
||||
#define NULL ((void *)0)
|
||||
|
||||
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
|
||||
|
||||
#endif
|
||||
@ -1,405 +0,0 @@
|
||||
#ifndef _STRING_H_
|
||||
#define _STRING_H_
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL ((void *) 0)
|
||||
#endif
|
||||
|
||||
#ifndef _SIZE_T
|
||||
#define _SIZE_T
|
||||
typedef unsigned int size_t;
|
||||
#endif
|
||||
|
||||
extern char * strerror(int errno);
|
||||
|
||||
/*
|
||||
* This string-include defines all string functions as inline
|
||||
* functions. Use gcc. It also assumes ds=es=data space, this should be
|
||||
* normal. Most of the string-functions are rather heavily hand-optimized,
|
||||
* see especially strtok,strstr,str[c]spn. They should work, but are not
|
||||
* very easy to understand. Everything is done entirely within the register
|
||||
* set, making the functions fast and clean. String instructions have been
|
||||
* used through-out, making for "slightly" unclear code :-)
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
extern inline char * strcpy(char * dest,const char *src)
|
||||
{
|
||||
__asm__("cld\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"stosb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b"
|
||||
::"S" (src),"D" (dest));
|
||||
return dest;
|
||||
}
|
||||
|
||||
extern inline char * strncpy(char * dest,const char *src,int count)
|
||||
{
|
||||
__asm__("cld\n"
|
||||
"1:\tdecl %2\n\t"
|
||||
"js 2f\n\t"
|
||||
"lodsb\n\t"
|
||||
"stosb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b\n\t"
|
||||
"rep\n\t"
|
||||
"stosb\n"
|
||||
"2:"
|
||||
::"S" (src),"D" (dest),"c" (count));
|
||||
return dest;
|
||||
}
|
||||
|
||||
extern inline char * strcat(char * dest,const char * src)
|
||||
{
|
||||
__asm__("cld\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"decl %1\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"stosb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b"
|
||||
::"S" (src),"D" (dest),"a" (0),"c" (0xffffffff));
|
||||
return dest;
|
||||
}
|
||||
|
||||
extern inline char * strncat(char * dest,const char * src,int count)
|
||||
{
|
||||
__asm__("cld\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"decl %1\n\t"
|
||||
"movl %4,%3\n"
|
||||
"1:\tdecl %3\n\t"
|
||||
"js 2f\n\t"
|
||||
"lodsb\n\t"
|
||||
"stosb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b\n"
|
||||
"2:\txorl %2,%2\n\t"
|
||||
"stosb"
|
||||
::"S" (src),"D" (dest),"a" (0),"c" (0xffffffff),"g" (count)
|
||||
);
|
||||
return dest;
|
||||
}
|
||||
|
||||
extern inline int strcmp(const char * cs,const char * ct)
|
||||
{
|
||||
register int __res __asm__("ax");
|
||||
__asm__("cld\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"scasb\n\t"
|
||||
"jne 2f\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b\n\t"
|
||||
"xorl %%eax,%%eax\n\t"
|
||||
"jmp 3f\n"
|
||||
"2:\tmovl $1,%%eax\n\t"
|
||||
"jl 3f\n\t"
|
||||
"negl %%eax\n"
|
||||
"3:"
|
||||
:"=a" (__res):"D" (cs),"S" (ct));
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline int strncmp(const char * cs,const char * ct,int count)
|
||||
{
|
||||
register int __res __asm__("ax");
|
||||
__asm__("cld\n"
|
||||
"1:\tdecl %3\n\t"
|
||||
"js 2f\n\t"
|
||||
"lodsb\n\t"
|
||||
"scasb\n\t"
|
||||
"jne 3f\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b\n"
|
||||
"2:\txorl %%eax,%%eax\n\t"
|
||||
"jmp 4f\n"
|
||||
"3:\tmovl $1,%%eax\n\t"
|
||||
"jl 4f\n\t"
|
||||
"negl %%eax\n"
|
||||
"4:"
|
||||
:"=a" (__res):"D" (cs),"S" (ct),"c" (count));
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline char * strchr(const char * s,char c)
|
||||
{
|
||||
register char * __res __asm__("ax");
|
||||
__asm__("cld\n\t"
|
||||
"movb %%al,%%ah\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"cmpb %%ah,%%al\n\t"
|
||||
"je 2f\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"jne 1b\n\t"
|
||||
"movl $1,%1\n"
|
||||
"2:\tmovl %1,%0\n\t"
|
||||
"decl %0"
|
||||
:"=a" (__res):"S" (s),"0" (c));
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline char * strrchr(const char * s,char c)
|
||||
{
|
||||
register char * __res __asm__("dx");
|
||||
__asm__("cld\n\t"
|
||||
"movb %%al,%%ah\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"cmpb %%ah,%%al\n\t"
|
||||
"jne 2f\n\t"
|
||||
"movl %%esi,%0\n\t"
|
||||
"decl %0\n"
|
||||
"2:\ttestb %%al,%%al\n\t"
|
||||
"jne 1b"
|
||||
:"=d" (__res):"0" (0),"S" (s),"a" (c));
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline int strspn(const char * cs, const char * ct)
|
||||
{
|
||||
register char * __res __asm__("si");
|
||||
__asm__("cld\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"notl %%ecx\n\t"
|
||||
"decl %%ecx\n\t"
|
||||
"movl %%ecx,%%edx\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"je 2f\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"movl %%edx,%%ecx\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"je 1b\n"
|
||||
"2:\tdecl %0"
|
||||
:"=S" (__res):"a" (0),"c" (0xffffffff),"0" (cs),"g" (ct)
|
||||
);
|
||||
return __res-cs;
|
||||
}
|
||||
|
||||
extern inline int strcspn(const char * cs, const char * ct)
|
||||
{
|
||||
register char * __res __asm__("si");
|
||||
__asm__("cld\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"notl %%ecx\n\t"
|
||||
"decl %%ecx\n\t"
|
||||
"movl %%ecx,%%edx\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"je 2f\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"movl %%edx,%%ecx\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"jne 1b\n"
|
||||
"2:\tdecl %0"
|
||||
:"=S" (__res):"a" (0),"c" (0xffffffff),"0" (cs),"g" (ct)
|
||||
);
|
||||
return __res-cs;
|
||||
}
|
||||
|
||||
extern inline char * strpbrk(const char * cs,const char * ct)
|
||||
{
|
||||
register char * __res __asm__("si");
|
||||
__asm__("cld\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"notl %%ecx\n\t"
|
||||
"decl %%ecx\n\t"
|
||||
"movl %%ecx,%%edx\n"
|
||||
"1:\tlodsb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"je 2f\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"movl %%edx,%%ecx\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"jne 1b\n\t"
|
||||
"decl %0\n\t"
|
||||
"jmp 3f\n"
|
||||
"2:\txorl %0,%0\n"
|
||||
"3:"
|
||||
:"=S" (__res):"a" (0),"c" (0xffffffff),"0" (cs),"g" (ct)
|
||||
);
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline char * strstr(const char * cs,const char * ct)
|
||||
{
|
||||
register char * __res __asm__("ax");
|
||||
__asm__("cld\n\t" \
|
||||
"movl %4,%%edi\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"notl %%ecx\n\t"
|
||||
"decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */
|
||||
"movl %%ecx,%%edx\n"
|
||||
"1:\tmovl %4,%%edi\n\t"
|
||||
"movl %%esi,%%eax\n\t"
|
||||
"movl %%edx,%%ecx\n\t"
|
||||
"repe\n\t"
|
||||
"cmpsb\n\t"
|
||||
"je 2f\n\t" /* also works for empty string, see above */
|
||||
"xchgl %%eax,%%esi\n\t"
|
||||
"incl %%esi\n\t"
|
||||
"cmpb $0,-1(%%eax)\n\t"
|
||||
"jne 1b\n\t"
|
||||
"xorl %%eax,%%eax\n\t"
|
||||
"2:"
|
||||
:"=a" (__res):"0" (0),"c" (0xffffffff),"S" (cs),"g" (ct)
|
||||
);
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline int strlen(const char * s)
|
||||
{
|
||||
register int __res ;
|
||||
__asm__("cld\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"notl %0\n\t"
|
||||
"decl %0"
|
||||
:"=c" (__res):"D" (s),"a" (0),"0" (0xffffffff));
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern char * ___strtok;
|
||||
|
||||
extern inline char * strtok(char * s,const char * ct)
|
||||
{
|
||||
register char * __res __asm__("si");
|
||||
__asm__("testl %1,%1\n\t"
|
||||
"jne 1f\n\t"
|
||||
"testl %0,%0\n\t"
|
||||
"je 8f\n\t"
|
||||
"movl %0,%1\n"
|
||||
"1:\txorl %0,%0\n\t"
|
||||
"movl $-1,%%ecx\n\t"
|
||||
"xorl %%eax,%%eax\n\t"
|
||||
"cld\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"notl %%ecx\n\t"
|
||||
"decl %%ecx\n\t"
|
||||
"je 7f\n\t" /* empty delimeter-string */
|
||||
"movl %%ecx,%%edx\n"
|
||||
"2:\tlodsb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"je 7f\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"movl %%edx,%%ecx\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"je 2b\n\t"
|
||||
"decl %1\n\t"
|
||||
"cmpb $0,(%1)\n\t"
|
||||
"je 7f\n\t"
|
||||
"movl %1,%0\n"
|
||||
"3:\tlodsb\n\t"
|
||||
"testb %%al,%%al\n\t"
|
||||
"je 5f\n\t"
|
||||
"movl %4,%%edi\n\t"
|
||||
"movl %%edx,%%ecx\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"jne 3b\n\t"
|
||||
"decl %1\n\t"
|
||||
"cmpb $0,(%1)\n\t"
|
||||
"je 5f\n\t"
|
||||
"movb $0,(%1)\n\t"
|
||||
"incl %1\n\t"
|
||||
"jmp 6f\n"
|
||||
"5:\txorl %1,%1\n"
|
||||
"6:\tcmpb $0,(%0)\n\t"
|
||||
"jne 7f\n\t"
|
||||
"xorl %0,%0\n"
|
||||
"7:\ttestl %0,%0\n\t"
|
||||
"jne 8f\n\t"
|
||||
"movl %0,%1\n"
|
||||
"8:"
|
||||
:"=b" (__res),"=S" (___strtok)
|
||||
:"0" (___strtok),"1" (s),"g" (ct)
|
||||
);
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline void * memcpy(void * dest,const void * src, int n)
|
||||
{
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"movsb"
|
||||
::"c" (n),"S" (src),"D" (dest)
|
||||
);
|
||||
return dest;
|
||||
}
|
||||
|
||||
extern inline void * memmove(void * dest,const void * src, int n)
|
||||
{
|
||||
if (dest<src)
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"movsb"
|
||||
::"c" (n),"S" (src),"D" (dest)
|
||||
);
|
||||
else
|
||||
__asm__("std\n\t"
|
||||
"rep\n\t"
|
||||
"movsb"
|
||||
::"c" (n),"S" (src+n-1),"D" (dest+n-1)
|
||||
);
|
||||
return dest;
|
||||
}
|
||||
|
||||
extern inline int memcmp(const void * cs,const void * ct,int count)
|
||||
{
|
||||
register int __res __asm__("ax");
|
||||
__asm__("cld\n\t"
|
||||
"repe\n\t"
|
||||
"cmpsb\n\t"
|
||||
"je 1f\n\t"
|
||||
"movl $1,%%eax\n\t"
|
||||
"jl 1f\n\t"
|
||||
"negl %%eax\n"
|
||||
"1:"
|
||||
:"=a" (__res):"0" (0),"D" (cs),"S" (ct),"c" (count)
|
||||
);
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline void * memchr(const void * cs,char c,int count)
|
||||
{
|
||||
register void * __res __asm__("di");
|
||||
if (!count)
|
||||
return NULL;
|
||||
__asm__("cld\n\t"
|
||||
"repne\n\t"
|
||||
"scasb\n\t"
|
||||
"je 1f\n\t"
|
||||
"movl $1,%0\n"
|
||||
"1:\tdecl %0"
|
||||
:"=D" (__res):"a" (c),"D" (cs),"c" (count)
|
||||
);
|
||||
return __res;
|
||||
}
|
||||
|
||||
extern inline void * memset(void * s,char c,int count)
|
||||
{
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"stosb"
|
||||
::"a" (c),"D" (s),"c" (count)
|
||||
);
|
||||
return s;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,60 +0,0 @@
|
||||
#ifndef _SYS_STAT_H
|
||||
#define _SYS_STAT_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
struct stat {
|
||||
dev_t st_dev;
|
||||
ino_t st_ino;
|
||||
umode_t st_mode;
|
||||
nlink_t st_nlink;
|
||||
uid_t st_uid;
|
||||
gid_t st_gid;
|
||||
dev_t st_rdev;
|
||||
off_t st_size;
|
||||
time_t st_atime;
|
||||
time_t st_mtime;
|
||||
time_t st_ctime;
|
||||
};
|
||||
|
||||
#define S_IFMT 00170000
|
||||
#define S_IFLNK 0120000
|
||||
#define S_IFREG 0100000
|
||||
#define S_IFBLK 0060000
|
||||
#define S_IFDIR 0040000
|
||||
#define S_IFCHR 0020000
|
||||
#define S_IFIFO 0010000
|
||||
#define S_ISUID 0004000
|
||||
#define S_ISGID 0002000
|
||||
#define S_ISVTX 0001000
|
||||
|
||||
#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
|
||||
#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
|
||||
#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
|
||||
#define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
|
||||
#define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
|
||||
#define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
|
||||
|
||||
#define S_IRWXU 00700
|
||||
#define S_IRUSR 00400
|
||||
#define S_IWUSR 00200
|
||||
#define S_IXUSR 00100
|
||||
|
||||
#define S_IRWXG 00070
|
||||
#define S_IRGRP 00040
|
||||
#define S_IWGRP 00020
|
||||
#define S_IXGRP 00010
|
||||
|
||||
#define S_IRWXO 00007
|
||||
#define S_IROTH 00004
|
||||
#define S_IWOTH 00002
|
||||
#define S_IXOTH 00001
|
||||
|
||||
extern int chmod(const char *_path, mode_t mode);
|
||||
extern int fstat(int fildes, struct stat *stat_buf);
|
||||
extern int mkdir(const char *_path, mode_t mode);
|
||||
extern int mkfifo(const char *_path, mode_t mode);
|
||||
extern int stat(const char *filename, struct stat *stat_buf);
|
||||
extern mode_t umask(mode_t mask);
|
||||
|
||||
#endif
|
||||
@ -1,15 +0,0 @@
|
||||
#ifndef _TIMES_H
|
||||
#define _TIMES_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
struct tms {
|
||||
time_t tms_utime;
|
||||
time_t tms_stime;
|
||||
time_t tms_cutime;
|
||||
time_t tms_cstime;
|
||||
};
|
||||
|
||||
extern time_t times(struct tms * tp);
|
||||
|
||||
#endif
|
||||
@ -1,46 +0,0 @@
|
||||
#ifndef _SYS_TYPES_H
|
||||
#define _SYS_TYPES_H
|
||||
|
||||
#ifndef _SIZE_T
|
||||
#define _SIZE_T
|
||||
typedef unsigned int size_t;
|
||||
#endif
|
||||
|
||||
#ifndef _TIME_T
|
||||
#define _TIME_T
|
||||
typedef long time_t;
|
||||
#endif
|
||||
|
||||
#ifndef _PTRDIFF_T
|
||||
#define _PTRDIFF_T
|
||||
typedef long ptrdiff_t;
|
||||
#endif
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL ((void *) 0)
|
||||
#endif
|
||||
|
||||
typedef int pid_t;
|
||||
typedef unsigned short uid_t;
|
||||
typedef unsigned char gid_t;
|
||||
typedef unsigned short dev_t;
|
||||
typedef unsigned short ino_t;
|
||||
typedef unsigned short mode_t;
|
||||
typedef unsigned short umode_t;
|
||||
typedef unsigned char nlink_t;
|
||||
typedef int daddr_t;
|
||||
typedef long off_t;
|
||||
typedef unsigned char u_char;
|
||||
typedef unsigned short ushort;
|
||||
|
||||
typedef struct { int quot,rem; } div_t;
|
||||
typedef struct { long quot,rem; } ldiv_t;
|
||||
|
||||
struct ustat {
|
||||
daddr_t f_tfree;
|
||||
ino_t f_tinode;
|
||||
char f_fname[6];
|
||||
char f_fpack[6];
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -1,16 +0,0 @@
|
||||
#ifndef _SYS_UTSNAME_H
|
||||
#define _SYS_UTSNAME_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
struct utsname {
|
||||
char sysname[9];
|
||||
char nodename[9];
|
||||
char release[9];
|
||||
char version[9];
|
||||
char machine[9];
|
||||
};
|
||||
|
||||
extern int uname(struct utsname * utsbuf);
|
||||
|
||||
#endif
|
||||
@ -1,23 +0,0 @@
|
||||
#ifndef _SYS_WAIT_H
|
||||
#define _SYS_WAIT_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#define _LOW(v) ( (v) & 0377)
|
||||
#define _HIGH(v) ( ((v) >> 8) & 0377)
|
||||
|
||||
/* options for waitpid, WUNTRACED not supported */
|
||||
#define WNOHANG 1
|
||||
#define WUNTRACED 2
|
||||
|
||||
#define WIFEXITED(s) (!((s)&0xFF)
|
||||
#define WIFSTOPPED(s) (((s)&0xFF)==0x7F)
|
||||
#define WEXITSTATUS(s) (((s)>>8)&0xFF)
|
||||
#define WTERMSIG(s) ((s)&0x7F)
|
||||
#define WSTOPSIG(s) (((s)>>8)&0xFF)
|
||||
#define WIFSIGNALED(s) (((unsigned int)(s)-1 & 0xFFFF) < 0xFF)
|
||||
|
||||
pid_t wait(int *stat_loc);
|
||||
pid_t waitpid(pid_t pid, int *stat_loc, int options);
|
||||
|
||||
#endif
|
||||
@ -1,228 +0,0 @@
|
||||
#ifndef _TERMIOS_H
|
||||
#define _TERMIOS_H
|
||||
|
||||
#define TTY_BUF_SIZE 1024
|
||||
|
||||
/* 0x54 is just a magic number to make these relatively uniqe ('T') */
|
||||
|
||||
#define TCGETS 0x5401
|
||||
#define TCSETS 0x5402
|
||||
#define TCSETSW 0x5403
|
||||
#define TCSETSF 0x5404
|
||||
#define TCGETA 0x5405
|
||||
#define TCSETA 0x5406
|
||||
#define TCSETAW 0x5407
|
||||
#define TCSETAF 0x5408
|
||||
#define TCSBRK 0x5409
|
||||
#define TCXONC 0x540A
|
||||
#define TCFLSH 0x540B
|
||||
#define TIOCEXCL 0x540C
|
||||
#define TIOCNXCL 0x540D
|
||||
#define TIOCSCTTY 0x540E
|
||||
#define TIOCGPGRP 0x540F
|
||||
#define TIOCSPGRP 0x5410
|
||||
#define TIOCOUTQ 0x5411
|
||||
#define TIOCSTI 0x5412
|
||||
#define TIOCGWINSZ 0x5413
|
||||
#define TIOCSWINSZ 0x5414
|
||||
#define TIOCMGET 0x5415
|
||||
#define TIOCMBIS 0x5416
|
||||
#define TIOCMBIC 0x5417
|
||||
#define TIOCMSET 0x5418
|
||||
#define TIOCGSOFTCAR 0x5419
|
||||
#define TIOCSSOFTCAR 0x541A
|
||||
#define TIOCINQ 0x541B
|
||||
|
||||
struct winsize {
|
||||
unsigned short ws_row;
|
||||
unsigned short ws_col;
|
||||
unsigned short ws_xpixel;
|
||||
unsigned short ws_ypixel;
|
||||
};
|
||||
|
||||
#define NCC 8
|
||||
struct termio {
|
||||
unsigned short c_iflag; /* input mode flags */
|
||||
unsigned short c_oflag; /* output mode flags */
|
||||
unsigned short c_cflag; /* control mode flags */
|
||||
unsigned short c_lflag; /* local mode flags */
|
||||
unsigned char c_line; /* line discipline */
|
||||
unsigned char c_cc[NCC]; /* control characters */
|
||||
};
|
||||
|
||||
#define NCCS 17
|
||||
struct termios {
|
||||
unsigned long c_iflag; /* input mode flags */
|
||||
unsigned long c_oflag; /* output mode flags */
|
||||
unsigned long c_cflag; /* control mode flags */
|
||||
unsigned long c_lflag; /* local mode flags */
|
||||
unsigned char c_line; /* line discipline */
|
||||
unsigned char c_cc[NCCS]; /* control characters */
|
||||
};
|
||||
|
||||
/* c_cc characters */
|
||||
#define VINTR 0
|
||||
#define VQUIT 1
|
||||
#define VERASE 2
|
||||
#define VKILL 3
|
||||
#define VEOF 4
|
||||
#define VTIME 5
|
||||
#define VMIN 6
|
||||
#define VSWTC 7
|
||||
#define VSTART 8
|
||||
#define VSTOP 9
|
||||
#define VSUSP 10
|
||||
#define VEOL 11
|
||||
#define VREPRINT 12
|
||||
#define VDISCARD 13
|
||||
#define VWERASE 14
|
||||
#define VLNEXT 15
|
||||
#define VEOL2 16
|
||||
|
||||
/* c_iflag bits */
|
||||
#define IGNBRK 0000001
|
||||
#define BRKINT 0000002
|
||||
#define IGNPAR 0000004
|
||||
#define PARMRK 0000010
|
||||
#define INPCK 0000020
|
||||
#define ISTRIP 0000040
|
||||
#define INLCR 0000100
|
||||
#define IGNCR 0000200
|
||||
#define ICRNL 0000400
|
||||
#define IUCLC 0001000
|
||||
#define IXON 0002000
|
||||
#define IXANY 0004000
|
||||
#define IXOFF 0010000
|
||||
#define IMAXBEL 0020000
|
||||
|
||||
/* c_oflag bits */
|
||||
#define OPOST 0000001
|
||||
#define OLCUC 0000002
|
||||
#define ONLCR 0000004
|
||||
#define OCRNL 0000010
|
||||
#define ONOCR 0000020
|
||||
#define ONLRET 0000040
|
||||
#define OFILL 0000100
|
||||
#define OFDEL 0000200
|
||||
#define NLDLY 0000400
|
||||
#define NL0 0000000
|
||||
#define NL1 0000400
|
||||
#define CRDLY 0003000
|
||||
#define CR0 0000000
|
||||
#define CR1 0001000
|
||||
#define CR2 0002000
|
||||
#define CR3 0003000
|
||||
#define TABDLY 0014000
|
||||
#define TAB0 0000000
|
||||
#define TAB1 0004000
|
||||
#define TAB2 0010000
|
||||
#define TAB3 0014000
|
||||
#define XTABS 0014000
|
||||
#define BSDLY 0020000
|
||||
#define BS0 0000000
|
||||
#define BS1 0020000
|
||||
#define VTDLY 0040000
|
||||
#define VT0 0000000
|
||||
#define VT1 0040000
|
||||
#define FFDLY 0040000
|
||||
#define FF0 0000000
|
||||
#define FF1 0040000
|
||||
|
||||
/* c_cflag bit meaning */
|
||||
#define CBAUD 0000017
|
||||
#define B0 0000000 /* hang up */
|
||||
#define B50 0000001
|
||||
#define B75 0000002
|
||||
#define B110 0000003
|
||||
#define B134 0000004
|
||||
#define B150 0000005
|
||||
#define B200 0000006
|
||||
#define B300 0000007
|
||||
#define B600 0000010
|
||||
#define B1200 0000011
|
||||
#define B1800 0000012
|
||||
#define B2400 0000013
|
||||
#define B4800 0000014
|
||||
#define B9600 0000015
|
||||
#define B19200 0000016
|
||||
#define B38400 0000017
|
||||
#define EXTA B19200
|
||||
#define EXTB B38400
|
||||
#define CSIZE 0000060
|
||||
#define CS5 0000000
|
||||
#define CS6 0000020
|
||||
#define CS7 0000040
|
||||
#define CS8 0000060
|
||||
#define CSTOPB 0000100
|
||||
#define CREAD 0000200
|
||||
#define CPARENB 0000400
|
||||
#define CPARODD 0001000
|
||||
#define HUPCL 0002000
|
||||
#define CLOCAL 0004000
|
||||
#define CIBAUD 03600000 /* input baud rate (not used) */
|
||||
#define CRTSCTS 020000000000 /* flow control */
|
||||
|
||||
#define PARENB CPARENB
|
||||
#define PARODD CPARODD
|
||||
|
||||
/* c_lflag bits */
|
||||
#define ISIG 0000001
|
||||
#define ICANON 0000002
|
||||
#define XCASE 0000004
|
||||
#define ECHO 0000010
|
||||
#define ECHOE 0000020
|
||||
#define ECHOK 0000040
|
||||
#define ECHONL 0000100
|
||||
#define NOFLSH 0000200
|
||||
#define TOSTOP 0000400
|
||||
#define ECHOCTL 0001000
|
||||
#define ECHOPRT 0002000
|
||||
#define ECHOKE 0004000
|
||||
#define FLUSHO 0010000
|
||||
#define PENDIN 0040000
|
||||
#define IEXTEN 0100000
|
||||
|
||||
/* modem lines */
|
||||
#define TIOCM_LE 0x001
|
||||
#define TIOCM_DTR 0x002
|
||||
#define TIOCM_RTS 0x004
|
||||
#define TIOCM_ST 0x008
|
||||
#define TIOCM_SR 0x010
|
||||
#define TIOCM_CTS 0x020
|
||||
#define TIOCM_CAR 0x040
|
||||
#define TIOCM_RNG 0x080
|
||||
#define TIOCM_DSR 0x100
|
||||
#define TIOCM_CD TIOCM_CAR
|
||||
#define TIOCM_RI TIOCM_RNG
|
||||
|
||||
/* tcflow() and TCXONC use these */
|
||||
#define TCOOFF 0
|
||||
#define TCOON 1
|
||||
#define TCIOFF 2
|
||||
#define TCION 3
|
||||
|
||||
/* tcflush() and TCFLSH use these */
|
||||
#define TCIFLUSH 0
|
||||
#define TCOFLUSH 1
|
||||
#define TCIOFLUSH 2
|
||||
|
||||
/* tcsetattr uses these */
|
||||
#define TCSANOW 0
|
||||
#define TCSADRAIN 1
|
||||
#define TCSAFLUSH 2
|
||||
|
||||
typedef int speed_t;
|
||||
|
||||
extern speed_t cfgetispeed(struct termios *termios_p);
|
||||
extern speed_t cfgetospeed(struct termios *termios_p);
|
||||
extern int cfsetispeed(struct termios *termios_p, speed_t speed);
|
||||
extern int cfsetospeed(struct termios *termios_p, speed_t speed);
|
||||
extern int tcdrain(int fildes);
|
||||
extern int tcflow(int fildes, int action);
|
||||
extern int tcflush(int fildes, int queue_selector);
|
||||
extern int tcgetattr(int fildes, struct termios *termios_p);
|
||||
extern int tcsendbreak(int fildes, int duration);
|
||||
extern int tcsetattr(int fildes, int optional_actions,
|
||||
struct termios *termios_p);
|
||||
|
||||
#endif
|
||||
@ -1,42 +0,0 @@
|
||||
#ifndef _TIME_H
|
||||
#define _TIME_H
|
||||
|
||||
#ifndef _TIME_T
|
||||
#define _TIME_T
|
||||
typedef long time_t;
|
||||
#endif
|
||||
|
||||
#ifndef _SIZE_T
|
||||
#define _SIZE_T
|
||||
typedef unsigned int size_t;
|
||||
#endif
|
||||
|
||||
#define CLOCKS_PER_SEC 100
|
||||
|
||||
typedef long clock_t;
|
||||
|
||||
struct tm {
|
||||
int tm_sec;
|
||||
int tm_min;
|
||||
int tm_hour;
|
||||
int tm_mday;
|
||||
int tm_mon;
|
||||
int tm_year;
|
||||
int tm_wday;
|
||||
int tm_yday;
|
||||
int tm_isdst;
|
||||
};
|
||||
|
||||
clock_t clock(void);
|
||||
time_t time(time_t * tp);
|
||||
double difftime(time_t time2, time_t time1);
|
||||
time_t mktime(struct tm * tp);
|
||||
|
||||
char * asctime(const struct tm * tp);
|
||||
char * ctime(const time_t * tp);
|
||||
struct tm * gmtime(const time_t *tp);
|
||||
struct tm *localtime(const time_t * tp);
|
||||
size_t strftime(char * s, size_t smax, const char * fmt, const struct tm * tp);
|
||||
void tzset(void);
|
||||
|
||||
#endif
|
||||
@ -1,275 +0,0 @@
|
||||
#ifndef _UNISTD_H
|
||||
#define _UNISTD_H
|
||||
|
||||
/* ok, this may be a joke, but I'm working on it */
|
||||
#define _POSIX_VERSION 198808L
|
||||
|
||||
#define _POSIX_CHOWN_RESTRICTED /* only root can do a chown (I think..) */
|
||||
#define _POSIX_NO_TRUNC /* no pathname truncation (but see in kernel) */
|
||||
#define _POSIX_VDISABLE '\0' /* character to disable things like ^C */
|
||||
/*#define _POSIX_SAVED_IDS */ /* we'll get to this yet */
|
||||
/*#define _POSIX_JOB_CONTROL */ /* we aren't there quite yet. Soon hopefully */
|
||||
|
||||
#define STDIN_FILENO 0
|
||||
#define STDOUT_FILENO 1
|
||||
#define STDERR_FILENO 2
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL ((void *)0)
|
||||
#endif
|
||||
|
||||
/* access */
|
||||
#define F_OK 0
|
||||
#define X_OK 1
|
||||
#define W_OK 2
|
||||
#define R_OK 4
|
||||
|
||||
/* lseek */
|
||||
#define SEEK_SET 0
|
||||
#define SEEK_CUR 1
|
||||
#define SEEK_END 2
|
||||
|
||||
/* _SC stands for System Configuration. We don't use them much */
|
||||
#define _SC_ARG_MAX 1
|
||||
#define _SC_CHILD_MAX 2
|
||||
#define _SC_CLOCKS_PER_SEC 3
|
||||
#define _SC_NGROUPS_MAX 4
|
||||
#define _SC_OPEN_MAX 5
|
||||
#define _SC_JOB_CONTROL 6
|
||||
#define _SC_SAVED_IDS 7
|
||||
#define _SC_VERSION 8
|
||||
|
||||
/* more (possibly) configurable things - now pathnames */
|
||||
#define _PC_LINK_MAX 1
|
||||
#define _PC_MAX_CANON 2
|
||||
#define _PC_MAX_INPUT 3
|
||||
#define _PC_NAME_MAX 4
|
||||
#define _PC_PATH_MAX 5
|
||||
#define _PC_PIPE_BUF 6
|
||||
#define _PC_NO_TRUNC 7
|
||||
#define _PC_VDISABLE 8
|
||||
#define _PC_CHOWN_RESTRICTED 9
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <sys/times.h>
|
||||
#include <sys/utsname.h>
|
||||
#include <utime.h>
|
||||
|
||||
#ifdef __LIBRARY__
|
||||
|
||||
#define __NR_setup 0 /* used only by init, to get system going */
|
||||
#define __NR_exit 1
|
||||
#define __NR_fork 2
|
||||
#define __NR_read 3
|
||||
#define __NR_write 4
|
||||
#define __NR_open 5
|
||||
#define __NR_close 6
|
||||
#define __NR_waitpid 7
|
||||
#define __NR_creat 8
|
||||
#define __NR_link 9
|
||||
#define __NR_unlink 10
|
||||
#define __NR_execve 11
|
||||
#define __NR_chdir 12
|
||||
#define __NR_time 13
|
||||
#define __NR_mknod 14
|
||||
#define __NR_chmod 15
|
||||
#define __NR_chown 16
|
||||
#define __NR_break 17
|
||||
#define __NR_stat 18
|
||||
#define __NR_lseek 19
|
||||
#define __NR_getpid 20
|
||||
#define __NR_mount 21
|
||||
#define __NR_umount 22
|
||||
#define __NR_setuid 23
|
||||
#define __NR_getuid 24
|
||||
#define __NR_stime 25
|
||||
#define __NR_ptrace 26
|
||||
#define __NR_alarm 27
|
||||
#define __NR_fstat 28
|
||||
#define __NR_pause 29
|
||||
#define __NR_utime 30
|
||||
#define __NR_stty 31
|
||||
#define __NR_gtty 32
|
||||
#define __NR_access 33
|
||||
#define __NR_nice 34
|
||||
#define __NR_ftime 35
|
||||
#define __NR_sync 36
|
||||
#define __NR_kill 37
|
||||
#define __NR_rename 38
|
||||
#define __NR_mkdir 39
|
||||
#define __NR_rmdir 40
|
||||
#define __NR_dup 41
|
||||
#define __NR_pipe 42
|
||||
#define __NR_times 43
|
||||
#define __NR_prof 44
|
||||
#define __NR_brk 45
|
||||
#define __NR_setgid 46
|
||||
#define __NR_getgid 47
|
||||
#define __NR_signal 48
|
||||
#define __NR_geteuid 49
|
||||
#define __NR_getegid 50
|
||||
#define __NR_acct 51
|
||||
#define __NR_phys 52
|
||||
#define __NR_lock 53
|
||||
#define __NR_ioctl 54
|
||||
#define __NR_fcntl 55
|
||||
#define __NR_mpx 56
|
||||
#define __NR_setpgid 57
|
||||
#define __NR_ulimit 58
|
||||
#define __NR_uname 59
|
||||
#define __NR_umask 60
|
||||
#define __NR_chroot 61
|
||||
#define __NR_ustat 62
|
||||
#define __NR_dup2 63
|
||||
#define __NR_getppid 64
|
||||
#define __NR_getpgrp 65
|
||||
#define __NR_setsid 66
|
||||
#define __NR_sigaction 67
|
||||
#define __NR_sgetmask 68
|
||||
#define __NR_ssetmask 69
|
||||
#define __NR_setreuid 70
|
||||
#define __NR_setregid 71
|
||||
#define __NR_sigsuspend 72
|
||||
#define __NR_sigpending 73
|
||||
#define __NR_sethostname 74
|
||||
#define __NR_setrlimit 75
|
||||
#define __NR_getrlimit 76
|
||||
#define __NR_getrusage 77
|
||||
#define __NR_gettimeofday 78
|
||||
#define __NR_settimeofday 79
|
||||
#define __NR_getgroups 80
|
||||
#define __NR_setgroups 81
|
||||
#define __NR_select 82
|
||||
#define __NR_symlink 83
|
||||
#define __NR_lstat 84
|
||||
#define __NR_readlink 85
|
||||
#define __NR_uselib 86
|
||||
#define __NR_execve2 87
|
||||
#define __NR_getdents 88
|
||||
#define __NR_getpipe2 89
|
||||
#define __NR_sleep 90
|
||||
#define __NR_getcwd 91
|
||||
|
||||
#define _syscall0(type,name) \
|
||||
type name(void) \
|
||||
{ \
|
||||
long __res; \
|
||||
__asm__ volatile ("int $0x80" \
|
||||
: "=a" (__res) \
|
||||
: "0" (__NR_##name)); \
|
||||
if (__res >= 0) \
|
||||
return (type) __res; \
|
||||
errno = -__res; \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
#define _syscall1(type,name,atype,a) \
|
||||
type name(atype a) \
|
||||
{ \
|
||||
long __res; \
|
||||
__asm__ volatile ("int $0x80" \
|
||||
: "=a" (__res) \
|
||||
: "0" (__NR_##name),"b" ((long)(a))); \
|
||||
if (__res >= 0) \
|
||||
return (type) __res; \
|
||||
errno = -__res; \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
#define _syscall2(type,name,atype,a,btype,b) \
|
||||
type name(atype a,btype b) \
|
||||
{ \
|
||||
long __res; \
|
||||
__asm__ volatile ("int $0x80" \
|
||||
: "=a" (__res) \
|
||||
: "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b))); \
|
||||
if (__res >= 0) \
|
||||
return (type) __res; \
|
||||
errno = -__res; \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
|
||||
type name(atype a,btype b,ctype c) \
|
||||
{ \
|
||||
long __res; \
|
||||
__asm__ volatile ("int $0x80" \
|
||||
: "=a" (__res) \
|
||||
: "0" (__NR_##name),"b" ((long)(a)),"c" ((long)(b)),"d" ((long)(c))); \
|
||||
if (__res>=0) \
|
||||
return (type) __res; \
|
||||
errno=-__res; \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
#endif /* __LIBRARY__ */
|
||||
|
||||
extern int errno;
|
||||
|
||||
int access(const char * filename, mode_t mode);
|
||||
int acct(const char * filename);
|
||||
int alarm(int sec);
|
||||
int brk(void * end_data_segment);
|
||||
void * sbrk(ptrdiff_t increment);
|
||||
int chdir(const char * filename);
|
||||
int chmod(const char * filename, mode_t mode);
|
||||
int chown(const char * filename, uid_t owner, gid_t group);
|
||||
int chroot(const char * filename);
|
||||
int close(int fildes);
|
||||
int creat(const char * filename, mode_t mode);
|
||||
int dup(int fildes);
|
||||
int execve(const char * filename, char ** argv, char ** envp);
|
||||
int execv(const char * pathname, char ** argv);
|
||||
int execvp(const char * file, char ** argv);
|
||||
int execl(const char * pathname, char * arg0, ...);
|
||||
int execlp(const char * file, char * arg0, ...);
|
||||
int execle(const char * pathname, char * arg0, ...);
|
||||
volatile void exit(int status);
|
||||
volatile void _exit(int status);
|
||||
int fcntl(int fildes, int cmd, ...);
|
||||
int fork(void);
|
||||
int getpid(void);
|
||||
int getuid(void);
|
||||
int geteuid(void);
|
||||
int getgid(void);
|
||||
int getegid(void);
|
||||
int ioctl(int fildes, int cmd, ...);
|
||||
int kill(pid_t pid, int signal);
|
||||
int link(const char * filename1, const char * filename2);
|
||||
int lseek(int fildes, off_t offset, int origin);
|
||||
int mknod(const char * filename, mode_t mode, dev_t dev);
|
||||
int mount(const char * specialfile, const char * dir, int rwflag);
|
||||
int nice(int val);
|
||||
int open(const char * filename, int flag, ...);
|
||||
int pause(void);
|
||||
int pipe(int * fildes);
|
||||
int read(int fildes, char * buf, off_t count);
|
||||
int setpgrp(void);
|
||||
int setpgid(pid_t pid,pid_t pgid);
|
||||
int setuid(uid_t uid);
|
||||
int setgid(gid_t gid);
|
||||
void (*signal(int sig, void (*fn)(int)))(int);
|
||||
int stat(const char * filename, struct stat * stat_buf);
|
||||
int fstat(int fildes, struct stat * stat_buf);
|
||||
int stime(time_t * tptr);
|
||||
int sync(void);
|
||||
time_t time(time_t * tloc);
|
||||
time_t times(struct tms * tbuf);
|
||||
int ulimit(int cmd, long limit);
|
||||
mode_t umask(mode_t mask);
|
||||
int umount(const char * specialfile);
|
||||
int uname(struct utsname * name);
|
||||
int unlink(const char * filename);
|
||||
int ustat(dev_t dev, struct ustat * ubuf);
|
||||
int utime(const char * filename, struct utimbuf * times);
|
||||
pid_t waitpid(pid_t pid,int * wait_stat,int options);
|
||||
pid_t wait(int * wait_stat);
|
||||
int write(int fildes, const char * buf, off_t count);
|
||||
int dup2(int oldfd, int newfd);
|
||||
int getppid(void);
|
||||
pid_t getpgrp(void);
|
||||
pid_t setsid(void);
|
||||
|
||||
#define __always_inline inline __attribute__((always_inline))
|
||||
|
||||
#endif
|
||||
@ -1,13 +0,0 @@
|
||||
#ifndef _UTIME_H
|
||||
#define _UTIME_H
|
||||
|
||||
#include <sys/types.h> /* I know - shouldn't do this, but .. */
|
||||
|
||||
struct utimbuf {
|
||||
time_t actime;
|
||||
time_t modtime;
|
||||
};
|
||||
|
||||
extern int utime(const char *filename, struct utimbuf *times);
|
||||
|
||||
#endif
|
||||
@ -1,210 +0,0 @@
|
||||
/*
|
||||
* linux/init/main.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
#define __LIBRARY__
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
|
||||
/*
|
||||
* we need this inline - forking from kernel space will result
|
||||
* in NO COPY ON WRITE (!!!), until an execve is executed. This
|
||||
* is no problem, but for the stack. This is handled by not letting
|
||||
* main() use the stack at all after fork(). Thus, no function
|
||||
* calls - which means inline code for fork too, as otherwise we
|
||||
* would use the stack upon exit from 'fork()'.
|
||||
*
|
||||
* Actually only pause and fork are needed inline, so that there
|
||||
* won't be any messing with the stack from main(), but we define
|
||||
* some others too.
|
||||
*/
|
||||
|
||||
__always_inline _syscall0(int,fork)
|
||||
__always_inline _syscall0(int,pause)
|
||||
__always_inline _syscall1(int,setup,void *,BIOS)
|
||||
__always_inline _syscall0(int,sync)
|
||||
|
||||
#include <linux/tty.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/head.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdarg.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <linux/fs.h>
|
||||
|
||||
static char printbuf[1024];
|
||||
|
||||
extern int vsprintf();
|
||||
extern void init(void);
|
||||
extern void blk_dev_init(void);
|
||||
extern void chr_dev_init(void);
|
||||
extern void hd_init(void);
|
||||
extern void floppy_init(void);
|
||||
extern void mem_init(long start, long end);
|
||||
extern long rd_init(long mem_start, int length);
|
||||
extern long kernel_mktime(struct tm * tm);
|
||||
extern long startup_time;
|
||||
|
||||
/*
|
||||
* This is set up by the setup-routine at boot-time
|
||||
*/
|
||||
#define EXT_MEM_K (*(unsigned short *)0x90002)
|
||||
#define DRIVE_INFO (*(struct drive_info *)0x90080)
|
||||
#define ORIG_ROOT_DEV (*(unsigned short *)0x901FC)
|
||||
|
||||
/*
|
||||
* Yeah, yeah, it's ugly, but I cannot find how to do this correctly
|
||||
* and this seems to work. I anybody has more info on the real-time
|
||||
* clock I'd be interested. Most of this was trial and error, and some
|
||||
* bios-listing reading. Urghh.
|
||||
*/
|
||||
|
||||
#define CMOS_READ(addr) ({ \
|
||||
outb_p(0x80|addr,0x70); \
|
||||
inb_p(0x71); \
|
||||
})
|
||||
|
||||
#define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10)
|
||||
|
||||
static void time_init(void)
|
||||
{
|
||||
struct tm time;
|
||||
|
||||
do {
|
||||
time.tm_sec = CMOS_READ(0);
|
||||
time.tm_min = CMOS_READ(2);
|
||||
time.tm_hour = CMOS_READ(4);
|
||||
time.tm_mday = CMOS_READ(7);
|
||||
time.tm_mon = CMOS_READ(8);
|
||||
time.tm_year = CMOS_READ(9);
|
||||
} while (time.tm_sec != CMOS_READ(0));
|
||||
BCD_TO_BIN(time.tm_sec);
|
||||
BCD_TO_BIN(time.tm_min);
|
||||
BCD_TO_BIN(time.tm_hour);
|
||||
BCD_TO_BIN(time.tm_mday);
|
||||
BCD_TO_BIN(time.tm_mon);
|
||||
BCD_TO_BIN(time.tm_year);
|
||||
time.tm_mon--;
|
||||
startup_time = kernel_mktime(&time);
|
||||
}
|
||||
|
||||
static long memory_end = 0;
|
||||
static long buffer_memory_end = 0;
|
||||
static long main_memory_start = 0;
|
||||
|
||||
struct drive_info { char dummy[32]; } drive_info;
|
||||
|
||||
void main(void) /* This really IS void, no error here. */
|
||||
{ /* The startup routine assumes (well, ...) this */
|
||||
/*
|
||||
* Interrupts are still disabled. Do necessary setups, then
|
||||
* enable them
|
||||
*/
|
||||
ROOT_DEV = ORIG_ROOT_DEV;
|
||||
__asm__ volatile ("cld"); /* by wyj */
|
||||
drive_info = DRIVE_INFO;
|
||||
memory_end = (1<<20) + (EXT_MEM_K<<10);
|
||||
memory_end &= 0xfffff000;
|
||||
if (memory_end > 16*1024*1024)
|
||||
memory_end = 16*1024*1024;
|
||||
if (memory_end > 12*1024*1024)
|
||||
buffer_memory_end = 4*1024*1024;
|
||||
else if (memory_end > 6*1024*1024)
|
||||
buffer_memory_end = 2*1024*1024;
|
||||
else
|
||||
buffer_memory_end = 1*1024*1024;
|
||||
main_memory_start = buffer_memory_end;
|
||||
#ifdef RAMDISK
|
||||
main_memory_start += rd_init(main_memory_start, RAMDISK*1024);
|
||||
#endif
|
||||
mem_init(main_memory_start,memory_end);
|
||||
trap_init();
|
||||
blk_dev_init();
|
||||
chr_dev_init();
|
||||
tty_init();
|
||||
time_init();
|
||||
sched_init();
|
||||
buffer_init(buffer_memory_end);
|
||||
hd_init();
|
||||
floppy_init();
|
||||
sti();
|
||||
move_to_user_mode();
|
||||
if (!fork()) { /* we count on this going ok */
|
||||
init();
|
||||
}
|
||||
/*
|
||||
* NOTE!! For any other task 'pause()' would mean we have to get a
|
||||
* signal to awaken, but task0 is the sole exception (see 'schedule()')
|
||||
* as task 0 gets activated at every idle moment (when no other tasks
|
||||
* can run). For task0 'pause()' just means we go check if some other
|
||||
* task can run, and if not we return here.
|
||||
*/
|
||||
for(;;) pause();
|
||||
}
|
||||
|
||||
static int printf(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int i;
|
||||
|
||||
va_start(args, fmt);
|
||||
write(1,printbuf,i=vsprintf(printbuf, fmt, args));
|
||||
va_end(args);
|
||||
return i;
|
||||
}
|
||||
|
||||
static char * argv_rc[] = { "/bin/sh", NULL };
|
||||
static char * envp_rc[] = { "HOME=/", NULL, NULL };
|
||||
|
||||
static char * argv[] = { "-/bin/sh",NULL };
|
||||
static char * envp[] = { "HOME=/usr/root", NULL, NULL };
|
||||
|
||||
void init(void)
|
||||
{
|
||||
int pid,i;
|
||||
|
||||
setup((void *) &drive_info);
|
||||
(void) open("/dev/tty0",O_RDWR,0);
|
||||
(void) dup(0);
|
||||
(void) dup(0);
|
||||
printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,
|
||||
NR_BUFFERS*BLOCK_SIZE);
|
||||
printf("Free mem: %d bytes\n\r",memory_end-main_memory_start);
|
||||
if (!(pid=fork())) {
|
||||
close(0);
|
||||
if (open("/etc/rc",O_RDONLY,0))
|
||||
_exit(1);
|
||||
execve("/bin/sh",argv_rc,envp_rc);
|
||||
_exit(2);
|
||||
}
|
||||
if (pid>0)
|
||||
while (pid != wait(&i))
|
||||
/* nothing */;
|
||||
while (1) {
|
||||
if ((pid=fork())<0) {
|
||||
printf("Fork failed in init\r\n");
|
||||
continue;
|
||||
}
|
||||
if (!pid) {
|
||||
close(0);close(1);close(2);
|
||||
setsid();
|
||||
(void) open("/dev/tty0",O_RDWR,0);
|
||||
(void) dup(0);
|
||||
(void) dup(0);
|
||||
_exit(execve("/bin/sh",argv,envp));
|
||||
}
|
||||
while (1)
|
||||
if (pid == wait(&i))
|
||||
break;
|
||||
printf("\n\rchild %d died with code %04x\n\r",pid,i);
|
||||
sync();
|
||||
}
|
||||
_exit(0); /* NOTE! _exit, not exit() */
|
||||
}
|
||||
Binary file not shown.
@ -1,83 +0,0 @@
|
||||
#
|
||||
# Makefile for the FREAX-kernel.
|
||||
#
|
||||
# Note! Dependencies are done automagically by 'make dep', which also
|
||||
# removes any old dependencies. DON'T put your own dependencies here
|
||||
# unless it's something special (ie not a .c file).
|
||||
#
|
||||
|
||||
AR =ar
|
||||
AS =as
|
||||
LD =ld
|
||||
LDFLAGS =-m elf_i386 -Ttext 0 -e startup_32
|
||||
CC =gcc -march=i386
|
||||
CFLAGS =-w -g -fomit-frame-pointer -finline-functions \
|
||||
-nostdinc -fno-stack-protector -mcld -I../include
|
||||
CPP =gcc -E -nostdinc -I../include
|
||||
|
||||
.c.s:
|
||||
$(CC) $(CFLAGS) \
|
||||
-S -o $*.s $<
|
||||
.s.o:
|
||||
$(AS) -o $*.o $<
|
||||
.c.o:
|
||||
$(CC) $(CFLAGS) \
|
||||
-c -o $*.o $<
|
||||
|
||||
OBJS = sched.o system_call.o traps.o asm.o fork.o \
|
||||
panic.o printk.o vsprintf.o sys.o exit.o \
|
||||
signal.o mktime.o
|
||||
|
||||
kernel.o: $(OBJS)
|
||||
$(LD) -r -o kernel.o $(OBJS)
|
||||
sync
|
||||
|
||||
clean:
|
||||
rm -f core *.o *.a tmp_make keyboard.s
|
||||
for i in *.c;do rm -f `basename $$i .c`.s;done
|
||||
(cd chr_drv; make clean)
|
||||
(cd blk_drv; make clean)
|
||||
(cd math; make clean)
|
||||
|
||||
dep:
|
||||
sed '/\#\#\# Dependencies/q' < Makefile > tmp_make
|
||||
(for i in *.c;do echo -n `echo $$i | sed 's,\.c,\.s,'`" "; \
|
||||
$(CPP) -M $$i;done) >> tmp_make
|
||||
cp tmp_make Makefile
|
||||
(cd chr_drv; make dep)
|
||||
(cd blk_drv; make dep)
|
||||
|
||||
### Dependencies:
|
||||
exit.s exit.o : exit.c ../include/errno.h ../include/signal.h \
|
||||
../include/sys/types.h ../include/sys/wait.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/linux/mm.h \
|
||||
../include/linux/kernel.h ../include/linux/tty.h ../include/termios.h \
|
||||
../include/asm/segment.h
|
||||
fork.s fork.o : fork.c ../include/errno.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h \
|
||||
../include/asm/segment.h ../include/asm/system.h
|
||||
mktime.s mktime.o : mktime.c ../include/time.h
|
||||
panic.s panic.o : panic.c ../include/linux/kernel.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h
|
||||
printk.s printk.o : printk.c ../include/stdarg.h ../include/stddef.h \
|
||||
../include/linux/kernel.h
|
||||
sched.s sched.o : sched.c ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/fs.h ../include/sys/types.h ../include/linux/mm.h \
|
||||
../include/signal.h ../include/linux/kernel.h ../include/linux/sys.h \
|
||||
../include/linux/fdreg.h ../include/asm/system.h ../include/asm/io.h \
|
||||
../include/asm/segment.h
|
||||
signal.s signal.o : signal.c ../include/linux/sched.h ../include/linux/head.h \
|
||||
../include/linux/fs.h ../include/sys/types.h ../include/linux/mm.h \
|
||||
../include/signal.h ../include/linux/kernel.h ../include/asm/segment.h
|
||||
sys.s sys.o : sys.c ../include/errno.h ../include/linux/sched.h \
|
||||
../include/linux/head.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/tty.h \
|
||||
../include/termios.h ../include/linux/kernel.h ../include/asm/segment.h \
|
||||
../include/sys/times.h ../include/sys/utsname.h
|
||||
traps.s traps.o : traps.c ../include/string.h ../include/linux/head.h \
|
||||
../include/linux/sched.h ../include/linux/fs.h ../include/sys/types.h \
|
||||
../include/linux/mm.h ../include/signal.h ../include/linux/kernel.h \
|
||||
../include/asm/system.h ../include/asm/segment.h ../include/asm/io.h
|
||||
vsprintf.s vsprintf.o : vsprintf.c ../include/stdarg.h ../include/string.h
|
||||
Binary file not shown.
@ -1,146 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/asm.s
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* asm.s contains the low-level code for most hardware faults.
|
||||
* page_exception is handled by the mm, so that isn't here. This
|
||||
* file also handles (hopefully) fpu-exceptions due to TS-bit, as
|
||||
* the fpu must be properly saved/resored. This hasn't been tested.
|
||||
*/
|
||||
|
||||
.globl divide_error,debug,nmi,int3,overflow,bounds,invalid_op
|
||||
.globl double_fault,coprocessor_segment_overrun
|
||||
.globl invalid_TSS,segment_not_present,stack_segment
|
||||
.globl general_protection,coprocessor_error,irq13,reserved
|
||||
|
||||
divide_error:
|
||||
pushl $do_divide_error
|
||||
no_error_code:
|
||||
xchgl %eax,(%esp)
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
pushl %edi
|
||||
pushl %esi
|
||||
pushl %ebp
|
||||
push %ds
|
||||
push %es
|
||||
push %fs
|
||||
pushl $0 # "error code"
|
||||
lea 44(%esp),%edx
|
||||
pushl %edx
|
||||
movl $0x10,%edx
|
||||
mov %dx,%ds
|
||||
mov %dx,%es
|
||||
mov %dx,%fs
|
||||
call *%eax
|
||||
addl $8,%esp
|
||||
pop %fs
|
||||
pop %es
|
||||
pop %ds
|
||||
popl %ebp
|
||||
popl %esi
|
||||
popl %edi
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %ebx
|
||||
popl %eax
|
||||
iret
|
||||
|
||||
debug:
|
||||
pushl $do_int3 # _do_debug
|
||||
jmp no_error_code
|
||||
|
||||
nmi:
|
||||
pushl $do_nmi
|
||||
jmp no_error_code
|
||||
|
||||
int3:
|
||||
pushl $do_int3
|
||||
jmp no_error_code
|
||||
|
||||
overflow:
|
||||
pushl $do_overflow
|
||||
jmp no_error_code
|
||||
|
||||
bounds:
|
||||
pushl $do_bounds
|
||||
jmp no_error_code
|
||||
|
||||
invalid_op:
|
||||
pushl $do_invalid_op
|
||||
jmp no_error_code
|
||||
|
||||
coprocessor_segment_overrun:
|
||||
pushl $do_coprocessor_segment_overrun
|
||||
jmp no_error_code
|
||||
|
||||
reserved:
|
||||
pushl $do_reserved
|
||||
jmp no_error_code
|
||||
|
||||
irq13:
|
||||
pushl %eax
|
||||
xorb %al,%al
|
||||
outb %al,$0xF0
|
||||
movb $0x20,%al
|
||||
outb %al,$0x20
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: outb %al,$0xA0
|
||||
popl %eax
|
||||
jmp coprocessor_error
|
||||
|
||||
double_fault:
|
||||
pushl $do_double_fault
|
||||
error_code:
|
||||
xchgl %eax,4(%esp) # error code <-> %eax
|
||||
xchgl %ebx,(%esp) # &function <-> %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
pushl %edi
|
||||
pushl %esi
|
||||
pushl %ebp
|
||||
push %ds
|
||||
push %es
|
||||
push %fs
|
||||
pushl %eax # error code
|
||||
lea 44(%esp),%eax # offset
|
||||
pushl %eax
|
||||
movl $0x10,%eax
|
||||
mov %ax,%ds
|
||||
mov %ax,%es
|
||||
mov %ax,%fs
|
||||
call *%ebx
|
||||
addl $8,%esp
|
||||
pop %fs
|
||||
pop %es
|
||||
pop %ds
|
||||
popl %ebp
|
||||
popl %esi
|
||||
popl %edi
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %ebx
|
||||
popl %eax
|
||||
iret
|
||||
|
||||
invalid_TSS:
|
||||
pushl $do_invalid_TSS
|
||||
jmp error_code
|
||||
|
||||
segment_not_present:
|
||||
pushl $do_segment_not_present
|
||||
jmp error_code
|
||||
|
||||
stack_segment:
|
||||
pushl $do_stack_segment
|
||||
jmp error_code
|
||||
|
||||
general_protection:
|
||||
pushl $do_general_protection
|
||||
jmp error_code
|
||||
|
||||
@ -1,58 +0,0 @@
|
||||
#
|
||||
# Makefile for the FREAX-kernel block device drivers.
|
||||
#
|
||||
# Note! Dependencies are done automagically by 'make dep', which also
|
||||
# removes any old dependencies. DON'T put your own dependencies here
|
||||
# unless it's something special (ie not a .c file).
|
||||
#
|
||||
|
||||
AR =ar
|
||||
AS =as
|
||||
LD =ld
|
||||
LDFLAGS =-s -x
|
||||
CC =gcc -march=i386
|
||||
CFLAGS =-w -g -fstrength-reduce -fomit-frame-pointer -mcld \
|
||||
-finline-functions -nostdinc -fno-stack-protector -I../../include
|
||||
CPP =gcc -E -nostdinc -I../../include
|
||||
|
||||
.c.s:
|
||||
$(CC) $(CFLAGS) \
|
||||
-S -o $*.s $<
|
||||
.s.o:
|
||||
$(AS) -o $*.o $<
|
||||
.c.o:
|
||||
$(CC) $(CFLAGS) \
|
||||
-c -o $*.o $<
|
||||
|
||||
OBJS = ll_rw_blk.o floppy.o hd.o ramdisk.o
|
||||
|
||||
blk_drv.a: $(OBJS)
|
||||
$(AR) rcs blk_drv.a $(OBJS)
|
||||
sync
|
||||
|
||||
clean:
|
||||
rm -f core *.o *.a tmp_make
|
||||
for i in *.c;do rm -f `basename $$i .c`.s;done
|
||||
|
||||
dep:
|
||||
sed '/\#\#\# Dependencies/q' < Makefile > tmp_make
|
||||
(for i in *.c;do echo -n `echo $$i | sed 's,\.c,\.s,'`" "; \
|
||||
$(CPP) -M $$i;done) >> tmp_make
|
||||
cp tmp_make Makefile
|
||||
|
||||
### Dependencies:
|
||||
floppy.s floppy.o : floppy.c ../../include/linux/sched.h ../../include/linux/head.h \
|
||||
../../include/linux/fs.h ../../include/sys/types.h ../../include/linux/mm.h \
|
||||
../../include/signal.h ../../include/linux/kernel.h \
|
||||
../../include/linux/fdreg.h ../../include/asm/system.h \
|
||||
../../include/asm/io.h ../../include/asm/segment.h blk.h
|
||||
hd.s hd.o : hd.c ../../include/linux/config.h ../../include/linux/sched.h \
|
||||
../../include/linux/head.h ../../include/linux/fs.h \
|
||||
../../include/sys/types.h ../../include/linux/mm.h ../../include/signal.h \
|
||||
../../include/linux/kernel.h ../../include/linux/hdreg.h \
|
||||
../../include/asm/system.h ../../include/asm/io.h \
|
||||
../../include/asm/segment.h blk.h
|
||||
ll_rw_blk.s ll_rw_blk.o : ll_rw_blk.c ../../include/errno.h ../../include/linux/sched.h \
|
||||
../../include/linux/head.h ../../include/linux/fs.h \
|
||||
../../include/sys/types.h ../../include/linux/mm.h ../../include/signal.h \
|
||||
../../include/linux/kernel.h ../../include/asm/system.h blk.h
|
||||
@ -1,140 +0,0 @@
|
||||
#ifndef _BLK_H
|
||||
#define _BLK_H
|
||||
|
||||
#define NR_BLK_DEV 7
|
||||
/*
|
||||
* NR_REQUEST is the number of entries in the request-queue.
|
||||
* NOTE that writes may use only the low 2/3 of these: reads
|
||||
* take precedence.
|
||||
*
|
||||
* 32 seems to be a reasonable number: enough to get some benefit
|
||||
* from the elevator-mechanism, but not so much as to lock a lot of
|
||||
* buffers when they are in the queue. 64 seems to be too many (easily
|
||||
* long pauses in reading when heavy writing/syncing is going on)
|
||||
*/
|
||||
#define NR_REQUEST 32
|
||||
|
||||
/*
|
||||
* Ok, this is an expanded form so that we can use the same
|
||||
* request for paging requests when that is implemented. In
|
||||
* paging, 'bh' is NULL, and 'waiting' is used to wait for
|
||||
* read/write completion.
|
||||
*/
|
||||
struct request {
|
||||
int dev; /* -1 if no request */
|
||||
int cmd; /* READ or WRITE */
|
||||
int errors;
|
||||
unsigned long sector;
|
||||
unsigned long nr_sectors;
|
||||
char * buffer;
|
||||
struct task_struct * waiting;
|
||||
struct buffer_head * bh;
|
||||
struct request * next;
|
||||
};
|
||||
|
||||
/*
|
||||
* This is used in the elevator algorithm: Note that
|
||||
* reads always go before writes. This is natural: reads
|
||||
* are much more time-critical than writes.
|
||||
*/
|
||||
#define IN_ORDER(s1,s2) \
|
||||
((s1)->cmd<(s2)->cmd || (s1)->cmd==(s2)->cmd && \
|
||||
((s1)->dev < (s2)->dev || ((s1)->dev == (s2)->dev && \
|
||||
(s1)->sector < (s2)->sector)))
|
||||
|
||||
struct blk_dev_struct {
|
||||
void (*request_fn)(void);
|
||||
struct request * current_request;
|
||||
};
|
||||
|
||||
extern struct blk_dev_struct blk_dev[NR_BLK_DEV];
|
||||
extern struct request request[NR_REQUEST];
|
||||
extern struct task_struct * wait_for_request;
|
||||
|
||||
#ifdef MAJOR_NR
|
||||
|
||||
/*
|
||||
* Add entries as needed. Currently the only block devices
|
||||
* supported are hard-disks and floppies.
|
||||
*/
|
||||
|
||||
#if (MAJOR_NR == 1)
|
||||
/* ram disk */
|
||||
#define DEVICE_NAME "ramdisk"
|
||||
#define DEVICE_REQUEST do_rd_request
|
||||
#define DEVICE_NR(device) ((device) & 7)
|
||||
#define DEVICE_ON(device)
|
||||
#define DEVICE_OFF(device)
|
||||
|
||||
#elif (MAJOR_NR == 2)
|
||||
/* floppy */
|
||||
#define DEVICE_NAME "floppy"
|
||||
#define DEVICE_INTR do_floppy
|
||||
#define DEVICE_REQUEST do_fd_request
|
||||
#define DEVICE_NR(device) ((device) & 3)
|
||||
#define DEVICE_ON(device) floppy_on(DEVICE_NR(device))
|
||||
#define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
|
||||
|
||||
#elif (MAJOR_NR == 3)
|
||||
/* harddisk */
|
||||
#define DEVICE_NAME "harddisk"
|
||||
#define DEVICE_INTR do_hd
|
||||
#define DEVICE_REQUEST do_hd_request
|
||||
#define DEVICE_NR(device) (MINOR(device)/5)
|
||||
#define DEVICE_ON(device)
|
||||
#define DEVICE_OFF(device)
|
||||
|
||||
#elif (MAJOR_NR > 3)
|
||||
/* unknown blk device */
|
||||
#error "unknown blk device"
|
||||
|
||||
#endif
|
||||
|
||||
#define CURRENT (blk_dev[MAJOR_NR].current_request)
|
||||
#define CURRENT_DEV DEVICE_NR(CURRENT->dev)
|
||||
|
||||
#ifdef DEVICE_INTR
|
||||
void (*DEVICE_INTR)(void) = NULL;
|
||||
#endif
|
||||
static void (DEVICE_REQUEST)(void);
|
||||
|
||||
static inline void unlock_buffer(struct buffer_head * bh)
|
||||
{
|
||||
if (!bh->b_lock)
|
||||
printk(DEVICE_NAME ": free buffer being unlocked\n");
|
||||
bh->b_lock=0;
|
||||
wake_up(&bh->b_wait);
|
||||
}
|
||||
|
||||
static inline void end_request(int uptodate)
|
||||
{
|
||||
DEVICE_OFF(CURRENT->dev);
|
||||
if (CURRENT->bh) {
|
||||
CURRENT->bh->b_uptodate = uptodate;
|
||||
unlock_buffer(CURRENT->bh);
|
||||
}
|
||||
if (!uptodate) {
|
||||
printk(DEVICE_NAME " I/O error\n\r");
|
||||
printk("dev %04x, block %d\n\r",CURRENT->dev,
|
||||
CURRENT->bh->b_blocknr);
|
||||
}
|
||||
wake_up(&CURRENT->waiting);
|
||||
wake_up(&wait_for_request);
|
||||
CURRENT->dev = -1;
|
||||
CURRENT = CURRENT->next;
|
||||
}
|
||||
|
||||
#define INIT_REQUEST \
|
||||
repeat: \
|
||||
if (!CURRENT) \
|
||||
return; \
|
||||
if (MAJOR(CURRENT->dev) != MAJOR_NR) \
|
||||
panic(DEVICE_NAME ": request list destroyed"); \
|
||||
if (CURRENT->bh) { \
|
||||
if (!CURRENT->bh->b_lock) \
|
||||
panic(DEVICE_NAME ": block not locked"); \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Binary file not shown.
@ -1,463 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/floppy.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* 02.12.91 - Changed to static variables to indicate need for reset
|
||||
* and recalibrate. This makes some things easier (output_byte reset
|
||||
* checking etc), and means less interrupt jumping in case of errors,
|
||||
* so the code is hopefully easier to understand.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is certainly a mess. I've tried my best to get it working,
|
||||
* but I don't like programming floppies, and I have only one anyway.
|
||||
* Urgel. I should check for more errors, and do more graceful error
|
||||
* recovery. Seems there are problems with several drives. I've tried to
|
||||
* correct them. No promises.
|
||||
*/
|
||||
|
||||
/*
|
||||
* As with hd.c, all routines within this file can (and will) be called
|
||||
* by interrupts, so extreme caution is needed. A hardware interrupt
|
||||
* handler may not sleep, or a kernel panic will happen. Thus I cannot
|
||||
* call "floppy-on" directly, but have to set a special timer interrupt
|
||||
* etc.
|
||||
*
|
||||
* Also, I'm not certain this works on more than 1 floppy. Bugs may
|
||||
* abund.
|
||||
*/
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/fdreg.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
#define MAJOR_NR 2
|
||||
#include "blk.h"
|
||||
|
||||
static int recalibrate = 0;
|
||||
static int reset = 0;
|
||||
static int seek = 0;
|
||||
|
||||
extern unsigned char current_DOR;
|
||||
|
||||
#define immoutb_p(val,port) \
|
||||
__asm__("outb %0,%1\n\tjmp 1f\n1:\tjmp 1f\n1:"::"a" ((char) (val)),"i" (port))
|
||||
|
||||
#define TYPE(x) ((x)>>2)
|
||||
#define DRIVE(x) ((x)&0x03)
|
||||
/*
|
||||
* Note that MAX_ERRORS=8 doesn't imply that we retry every bad read
|
||||
* max 8 times - some types of errors increase the errorcount by 2,
|
||||
* so we might actually retry only 5-6 times before giving up.
|
||||
*/
|
||||
#define MAX_ERRORS 8
|
||||
|
||||
/*
|
||||
* globals used by 'result()'
|
||||
*/
|
||||
#define MAX_REPLIES 7
|
||||
static unsigned char reply_buffer[MAX_REPLIES];
|
||||
#define ST0 (reply_buffer[0])
|
||||
#define ST1 (reply_buffer[1])
|
||||
#define ST2 (reply_buffer[2])
|
||||
#define ST3 (reply_buffer[3])
|
||||
|
||||
/*
|
||||
* This struct defines the different floppy types. Unlike minix
|
||||
* linux doesn't have a "search for right type"-type, as the code
|
||||
* for that is convoluted and weird. I've got enough problems with
|
||||
* this driver as it is.
|
||||
*
|
||||
* The 'stretch' tells if the tracks need to be boubled for some
|
||||
* types (ie 360kB diskette in 1.2MB drive etc). Others should
|
||||
* be self-explanatory.
|
||||
*/
|
||||
static struct floppy_struct {
|
||||
unsigned int size, sect, head, track, stretch;
|
||||
unsigned char gap,rate,spec1;
|
||||
} floppy_type[] = {
|
||||
{ 0, 0,0, 0,0,0x00,0x00,0x00 }, /* no testing */
|
||||
{ 720, 9,2,40,0,0x2A,0x02,0xDF }, /* 360kB PC diskettes */
|
||||
{ 2400,15,2,80,0,0x1B,0x00,0xDF }, /* 1.2 MB AT-diskettes */
|
||||
{ 720, 9,2,40,1,0x2A,0x02,0xDF }, /* 360kB in 720kB drive */
|
||||
{ 1440, 9,2,80,0,0x2A,0x02,0xDF }, /* 3.5" 720kB diskette */
|
||||
{ 720, 9,2,40,1,0x23,0x01,0xDF }, /* 360kB in 1.2MB drive */
|
||||
{ 1440, 9,2,80,0,0x23,0x01,0xDF }, /* 720kB in 1.2MB drive */
|
||||
{ 2880,18,2,80,0,0x1B,0x00,0xCF }, /* 1.44MB diskette */
|
||||
};
|
||||
/*
|
||||
* Rate is 0 for 500kb/s, 2 for 300kbps, 1 for 250kbps
|
||||
* Spec1 is 0xSH, where S is stepping rate (F=1ms, E=2ms, D=3ms etc),
|
||||
* H is head unload time (1=16ms, 2=32ms, etc)
|
||||
*
|
||||
* Spec2 is (HLD<<1 | ND), where HLD is head load time (1=2ms, 2=4 ms etc)
|
||||
* and ND is set means no DMA. Hardcoded to 6 (HLD=6ms, use DMA).
|
||||
*/
|
||||
|
||||
extern void floppy_interrupt(void);
|
||||
extern char tmp_floppy_area[1024];
|
||||
|
||||
/*
|
||||
* These are global variables, as that's the easiest way to give
|
||||
* information to interrupts. They are the data used for the current
|
||||
* request.
|
||||
*/
|
||||
static int cur_spec1 = -1;
|
||||
static int cur_rate = -1;
|
||||
static struct floppy_struct * floppy = floppy_type;
|
||||
static unsigned char current_drive = 0;
|
||||
static unsigned char sector = 0;
|
||||
static unsigned char head = 0;
|
||||
static unsigned char track = 0;
|
||||
static unsigned char seek_track = 0;
|
||||
static unsigned char current_track = 255;
|
||||
static unsigned char command = 0;
|
||||
unsigned char selected = 0;
|
||||
struct task_struct * wait_on_floppy_select = NULL;
|
||||
|
||||
void floppy_deselect(unsigned int nr)
|
||||
{
|
||||
if (nr != (current_DOR & 3))
|
||||
printk("floppy_deselect: drive not selected\n\r");
|
||||
selected = 0;
|
||||
wake_up(&wait_on_floppy_select);
|
||||
}
|
||||
|
||||
/*
|
||||
* floppy-change is never called from an interrupt, so we can relax a bit
|
||||
* here, sleep etc. Note that floppy-on tries to set current_DOR to point
|
||||
* to the desired drive, but it will probably not survive the sleep if
|
||||
* several floppies are used at the same time: thus the loop.
|
||||
*/
|
||||
int floppy_change(unsigned int nr)
|
||||
{
|
||||
repeat:
|
||||
floppy_on(nr);
|
||||
while ((current_DOR & 3) != nr && selected)
|
||||
interruptible_sleep_on(&wait_on_floppy_select);
|
||||
if ((current_DOR & 3) != nr)
|
||||
goto repeat;
|
||||
if (inb(FD_DIR) & 0x80) {
|
||||
floppy_off(nr);
|
||||
return 1;
|
||||
}
|
||||
floppy_off(nr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define copy_buffer(from,to) \
|
||||
__asm__("cld ; rep ; movsl" \
|
||||
::"c" (BLOCK_SIZE/4),"S" ((long)(from)),"D" ((long)(to)) \
|
||||
)
|
||||
|
||||
static void setup_DMA(void)
|
||||
{
|
||||
long addr = (long) CURRENT->buffer;
|
||||
|
||||
cli();
|
||||
if (addr >= 0x100000) {
|
||||
addr = (long) tmp_floppy_area;
|
||||
if (command == FD_WRITE)
|
||||
copy_buffer(CURRENT->buffer,tmp_floppy_area);
|
||||
}
|
||||
/* mask DMA 2 */
|
||||
immoutb_p(4|2,10);
|
||||
/* output command byte. I don't know why, but everyone (minix, */
|
||||
/* sanches & canton) output this twice, first to 12 then to 11 */
|
||||
__asm__("outb %%al,$12\n\tjmp 1f\n1:\tjmp 1f\n1:\t"
|
||||
"outb %%al,$11\n\tjmp 1f\n1:\tjmp 1f\n1:"::
|
||||
"a" ((char) ((command == FD_READ)?DMA_READ:DMA_WRITE)));
|
||||
/* 8 low bits of addr */
|
||||
immoutb_p(addr,4);
|
||||
addr >>= 8;
|
||||
/* bits 8-15 of addr */
|
||||
immoutb_p(addr,4);
|
||||
addr >>= 8;
|
||||
/* bits 16-19 of addr */
|
||||
immoutb_p(addr,0x81);
|
||||
/* low 8 bits of count-1 (1024-1=0x3ff) */
|
||||
immoutb_p(0xff,5);
|
||||
/* high 8 bits of count-1 */
|
||||
immoutb_p(3,5);
|
||||
/* activate DMA 2 */
|
||||
immoutb_p(0|2,10);
|
||||
sti();
|
||||
}
|
||||
|
||||
static void output_byte(char byte)
|
||||
{
|
||||
int counter;
|
||||
unsigned char status;
|
||||
|
||||
if (reset)
|
||||
return;
|
||||
for(counter = 0 ; counter < 10000 ; counter++) {
|
||||
status = inb_p(FD_STATUS) & (STATUS_READY | STATUS_DIR);
|
||||
if (status == STATUS_READY) {
|
||||
outb(byte,FD_DATA);
|
||||
return;
|
||||
}
|
||||
}
|
||||
reset = 1;
|
||||
printk("Unable to send byte to FDC\n\r");
|
||||
}
|
||||
|
||||
static int result(void)
|
||||
{
|
||||
int i = 0, counter, status;
|
||||
|
||||
if (reset)
|
||||
return -1;
|
||||
for (counter = 0 ; counter < 10000 ; counter++) {
|
||||
status = inb_p(FD_STATUS)&(STATUS_DIR|STATUS_READY|STATUS_BUSY);
|
||||
if (status == STATUS_READY)
|
||||
return i;
|
||||
if (status == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) {
|
||||
if (i >= MAX_REPLIES)
|
||||
break;
|
||||
reply_buffer[i++] = inb_p(FD_DATA);
|
||||
}
|
||||
}
|
||||
reset = 1;
|
||||
printk("Getstatus times out\n\r");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void bad_flp_intr(void)
|
||||
{
|
||||
CURRENT->errors++;
|
||||
if (CURRENT->errors > MAX_ERRORS) {
|
||||
floppy_deselect(current_drive);
|
||||
end_request(0);
|
||||
}
|
||||
if (CURRENT->errors > MAX_ERRORS/2)
|
||||
reset = 1;
|
||||
else
|
||||
recalibrate = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, this interrupt is called after a DMA read/write has succeeded,
|
||||
* so we check the results, and copy any buffers.
|
||||
*/
|
||||
static void rw_interrupt(void)
|
||||
{
|
||||
if (result() != 7 || (ST0 & 0xf8) || (ST1 & 0xbf) || (ST2 & 0x73)) {
|
||||
if (ST1 & 0x02) {
|
||||
printk("Drive %d is write protected\n\r",current_drive);
|
||||
floppy_deselect(current_drive);
|
||||
end_request(0);
|
||||
} else
|
||||
bad_flp_intr();
|
||||
do_fd_request();
|
||||
return;
|
||||
}
|
||||
if (command == FD_READ && (unsigned long)(CURRENT->buffer) >= 0x100000)
|
||||
copy_buffer(tmp_floppy_area,CURRENT->buffer);
|
||||
floppy_deselect(current_drive);
|
||||
end_request(1);
|
||||
do_fd_request();
|
||||
}
|
||||
|
||||
inline void setup_rw_floppy(void)
|
||||
{
|
||||
setup_DMA();
|
||||
do_floppy = rw_interrupt;
|
||||
output_byte(command);
|
||||
output_byte(head<<2 | current_drive);
|
||||
output_byte(track);
|
||||
output_byte(head);
|
||||
output_byte(sector);
|
||||
output_byte(2); /* sector size = 512 */
|
||||
output_byte(floppy->sect);
|
||||
output_byte(floppy->gap);
|
||||
output_byte(0xFF); /* sector size (0xff when n!=0 ?) */
|
||||
if (reset)
|
||||
do_fd_request();
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the routine called after every seek (or recalibrate) interrupt
|
||||
* from the floppy controller. Note that the "unexpected interrupt" routine
|
||||
* also does a recalibrate, but doesn't come here.
|
||||
*/
|
||||
static void seek_interrupt(void)
|
||||
{
|
||||
/* sense drive status */
|
||||
output_byte(FD_SENSEI);
|
||||
if (result() != 2 || (ST0 & 0xF8) != 0x20 || ST1 != seek_track) {
|
||||
bad_flp_intr();
|
||||
do_fd_request();
|
||||
return;
|
||||
}
|
||||
current_track = ST1;
|
||||
setup_rw_floppy();
|
||||
}
|
||||
|
||||
/*
|
||||
* This routine is called when everything should be correctly set up
|
||||
* for the transfer (ie floppy motor is on and the correct floppy is
|
||||
* selected).
|
||||
*/
|
||||
static void transfer(void)
|
||||
{
|
||||
if (cur_spec1 != floppy->spec1) {
|
||||
cur_spec1 = floppy->spec1;
|
||||
output_byte(FD_SPECIFY);
|
||||
output_byte(cur_spec1); /* hut etc */
|
||||
output_byte(6); /* Head load time =6ms, DMA */
|
||||
}
|
||||
if (cur_rate != floppy->rate)
|
||||
outb_p(cur_rate = floppy->rate,FD_DCR);
|
||||
if (reset) {
|
||||
do_fd_request();
|
||||
return;
|
||||
}
|
||||
if (!seek) {
|
||||
setup_rw_floppy();
|
||||
return;
|
||||
}
|
||||
do_floppy = seek_interrupt;
|
||||
if (seek_track) {
|
||||
output_byte(FD_SEEK);
|
||||
output_byte(head<<2 | current_drive);
|
||||
output_byte(seek_track);
|
||||
} else {
|
||||
output_byte(FD_RECALIBRATE);
|
||||
output_byte(head<<2 | current_drive);
|
||||
}
|
||||
if (reset)
|
||||
do_fd_request();
|
||||
}
|
||||
|
||||
/*
|
||||
* Special case - used after a unexpected interrupt (or reset)
|
||||
*/
|
||||
static void recal_interrupt(void)
|
||||
{
|
||||
output_byte(FD_SENSEI);
|
||||
if (result()!=2 || (ST0 & 0xE0) == 0x60)
|
||||
reset = 1;
|
||||
else
|
||||
recalibrate = 0;
|
||||
do_fd_request();
|
||||
}
|
||||
|
||||
void unexpected_floppy_interrupt(void)
|
||||
{
|
||||
output_byte(FD_SENSEI);
|
||||
if (result()!=2 || (ST0 & 0xE0) == 0x60)
|
||||
reset = 1;
|
||||
else
|
||||
recalibrate = 1;
|
||||
}
|
||||
|
||||
static void recalibrate_floppy(void)
|
||||
{
|
||||
recalibrate = 0;
|
||||
current_track = 0;
|
||||
current_drive = 1; /* by wyj, ?? */
|
||||
do_floppy = recal_interrupt;
|
||||
output_byte(FD_RECALIBRATE);
|
||||
output_byte(head<<2 | current_drive);
|
||||
if (reset)
|
||||
do_fd_request();
|
||||
}
|
||||
|
||||
static void reset_interrupt(void)
|
||||
{
|
||||
output_byte(FD_SENSEI);
|
||||
(void) result();
|
||||
output_byte(FD_SPECIFY);
|
||||
output_byte(cur_spec1); /* hut etc */
|
||||
output_byte(6); /* Head load time =6ms, DMA */
|
||||
do_fd_request();
|
||||
}
|
||||
|
||||
/*
|
||||
* reset is done by pulling bit 2 of DOR low for a while.
|
||||
*/
|
||||
static void reset_floppy(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
reset = 0;
|
||||
cur_spec1 = -1;
|
||||
cur_rate = -1;
|
||||
recalibrate = 1;
|
||||
printk("Reset-floppy called\n\r");
|
||||
cli();
|
||||
do_floppy = reset_interrupt;
|
||||
outb_p(current_DOR & ~0x04,FD_DOR);
|
||||
for (i=0 ; i<100 ; i++)
|
||||
__asm__("nop");
|
||||
outb(current_DOR,FD_DOR);
|
||||
sti();
|
||||
}
|
||||
|
||||
static void floppy_on_interrupt(void)
|
||||
{
|
||||
/* We cannot do a floppy-select, as that might sleep. We just force it */
|
||||
selected = 1;
|
||||
if (current_drive != (current_DOR & 3)) {
|
||||
current_DOR &= 0xFC;
|
||||
current_DOR |= current_drive;
|
||||
outb(current_DOR,FD_DOR);
|
||||
add_timer(2,&transfer);
|
||||
} else
|
||||
transfer();
|
||||
}
|
||||
|
||||
void do_fd_request(void)
|
||||
{
|
||||
unsigned int block;
|
||||
|
||||
seek = 0;
|
||||
if (reset) {
|
||||
reset_floppy();
|
||||
return;
|
||||
}
|
||||
if (recalibrate) {
|
||||
recalibrate_floppy();
|
||||
return;
|
||||
}
|
||||
INIT_REQUEST;
|
||||
floppy = (MINOR(CURRENT->dev)>>2) + floppy_type;
|
||||
if (current_drive != CURRENT_DEV)
|
||||
seek = 1;
|
||||
current_drive = CURRENT_DEV;
|
||||
block = CURRENT->sector;
|
||||
if (block+2 > floppy->size) {
|
||||
end_request(0);
|
||||
goto repeat;
|
||||
}
|
||||
sector = block % floppy->sect;
|
||||
block /= floppy->sect;
|
||||
head = block % floppy->head;
|
||||
track = block / floppy->head;
|
||||
seek_track = track << floppy->stretch;
|
||||
if (seek_track != current_track)
|
||||
seek = 1;
|
||||
sector++;
|
||||
if (CURRENT->cmd == READ)
|
||||
command = FD_READ;
|
||||
else if (CURRENT->cmd == WRITE)
|
||||
command = FD_WRITE;
|
||||
else
|
||||
panic("do_fd_request: unknown command");
|
||||
add_timer(ticks_to_floppy_on(current_drive),&floppy_on_interrupt);
|
||||
}
|
||||
|
||||
void floppy_init(void)
|
||||
{
|
||||
blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
|
||||
set_trap_gate(0x26,&floppy_interrupt);
|
||||
outb(inb_p(0x21)&~0x40,0x21);
|
||||
}
|
||||
Binary file not shown.
@ -1,351 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/hd.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* This is the low-level hd interrupt support. It traverses the
|
||||
* request-list, using interrupts to jump between functions. As
|
||||
* all the functions are called within interrupts, we may not
|
||||
* sleep. Special care is recommended.
|
||||
*
|
||||
* modified by Drew Eckhardt to check nr of hd's from the CMOS.
|
||||
*/
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/hdreg.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/segment.h>
|
||||
|
||||
#define MAJOR_NR 3
|
||||
#include "blk.h"
|
||||
|
||||
#define CMOS_READ(addr) ({ \
|
||||
outb_p(0x80|addr,0x70); \
|
||||
inb_p(0x71); \
|
||||
})
|
||||
|
||||
/* Max read/write errors/sector */
|
||||
#define MAX_ERRORS 7
|
||||
#define MAX_HD 2
|
||||
|
||||
static void recal_intr(void);
|
||||
|
||||
static int recalibrate = 0; /* 1, wen */
|
||||
static int reset = 0;
|
||||
|
||||
/*
|
||||
* This struct defines the HD's and their types.
|
||||
*/
|
||||
struct hd_i_struct {
|
||||
int head,sect,cyl,wpcom,lzone,ctl;
|
||||
};
|
||||
#ifdef HD_TYPE
|
||||
struct hd_i_struct hd_info[] = { HD_TYPE };
|
||||
#define NR_HD ((sizeof (hd_info))/(sizeof (struct hd_i_struct)))
|
||||
#else
|
||||
struct hd_i_struct hd_info[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };
|
||||
static int NR_HD = 0;
|
||||
#endif
|
||||
|
||||
static struct hd_struct {
|
||||
long start_sect;
|
||||
long nr_sects;
|
||||
} hd[5*MAX_HD]={{0,0},};
|
||||
|
||||
#define port_read(port,buf,nr) \
|
||||
__asm__("cld;rep;insw"::"d" (port),"D" (buf),"c" (nr))
|
||||
|
||||
#define port_write(port,buf,nr) \
|
||||
__asm__("cld;rep;outsw"::"d" (port),"S" (buf),"c" (nr))
|
||||
|
||||
extern void hd_interrupt(void);
|
||||
extern void rd_load(void);
|
||||
|
||||
/* This may be used only once, enforced by 'static int callable' */
|
||||
int sys_setup(void * BIOS)
|
||||
{
|
||||
static int callable = 1;
|
||||
int i,drive;
|
||||
unsigned char cmos_disks;
|
||||
struct partition *p;
|
||||
struct buffer_head * bh;
|
||||
|
||||
if (!callable)
|
||||
return -1;
|
||||
callable = 0;
|
||||
#ifndef HD_TYPE
|
||||
for (drive=0 ; drive<2 ; drive++) {
|
||||
hd_info[drive].cyl = *(unsigned short *) BIOS;
|
||||
hd_info[drive].head = *(unsigned char *) (2+BIOS);
|
||||
hd_info[drive].wpcom = *(unsigned short *) (5+BIOS);
|
||||
hd_info[drive].ctl = *(unsigned char *) (8+BIOS);
|
||||
hd_info[drive].lzone = *(unsigned short *) (12+BIOS);
|
||||
hd_info[drive].sect = *(unsigned char *) (14+BIOS);
|
||||
BIOS += 16;
|
||||
}
|
||||
if (hd_info[1].cyl)
|
||||
NR_HD=2;
|
||||
else
|
||||
NR_HD=1;
|
||||
#endif
|
||||
for (i=0 ; i<NR_HD ; i++) {
|
||||
hd[i*5].start_sect = 0;
|
||||
hd[i*5].nr_sects = hd_info[i].head*
|
||||
hd_info[i].sect*hd_info[i].cyl;
|
||||
}
|
||||
|
||||
/*
|
||||
We querry CMOS about hard disks : it could be that
|
||||
we have a SCSI/ESDI/etc controller that is BIOS
|
||||
compatable with ST-506, and thus showing up in our
|
||||
BIOS table, but not register compatable, and therefore
|
||||
not present in CMOS.
|
||||
|
||||
Furthurmore, we will assume that our ST-506 drives
|
||||
<if any> are the primary drives in the system, and
|
||||
the ones reflected as drive 1 or 2.
|
||||
|
||||
The first drive is stored in the high nibble of CMOS
|
||||
byte 0x12, the second in the low nibble. This will be
|
||||
either a 4 bit drive type or 0xf indicating use byte 0x19
|
||||
for an 8 bit type, drive 1, 0x1a for drive 2 in CMOS.
|
||||
|
||||
Needless to say, a non-zero value means we have
|
||||
an AT controller hard disk for that drive.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
if ((cmos_disks = CMOS_READ(0x12)) & 0xf0)
|
||||
if (cmos_disks & 0x0f)
|
||||
NR_HD = 2;
|
||||
else
|
||||
NR_HD = 1;
|
||||
else
|
||||
NR_HD = 0;
|
||||
for (i = NR_HD ; i < 2 ; i++) {
|
||||
hd[i*5].start_sect = 0;
|
||||
hd[i*5].nr_sects = 0;
|
||||
}
|
||||
for (drive=0 ; drive<NR_HD ; drive++) {
|
||||
if (!(bh = bread(0x300 + drive*5,0))) {
|
||||
printk("Unable to read partition table of drive %d\n\r",
|
||||
drive);
|
||||
panic("");
|
||||
}
|
||||
if (bh->b_data[510] != 0x55 || (unsigned char)
|
||||
bh->b_data[511] != 0xAA) {
|
||||
printk("Bad partition table on drive %d\n\r",drive);
|
||||
panic("");
|
||||
}
|
||||
p = 0x1BE + (void *)bh->b_data;
|
||||
for (i=1;i<5;i++,p++) {
|
||||
hd[i+5*drive].start_sect = p->start_sect;
|
||||
hd[i+5*drive].nr_sects = p->nr_sects;
|
||||
}
|
||||
brelse(bh);
|
||||
}
|
||||
if (NR_HD)
|
||||
printk("Partition table%s ok.\n\r",(NR_HD>1)?"s":"");
|
||||
rd_load();
|
||||
mount_root();
|
||||
return (0);
|
||||
}
|
||||
|
||||
static int controller_ready(void)
|
||||
{
|
||||
/* int retries=10000; */
|
||||
int retries=100000;
|
||||
|
||||
/* while (--retries && (inb_p(HD_STATUS)&0xc0)!=0x40); */
|
||||
while (--retries && (inb_p(HD_STATUS)&0x80));
|
||||
return (retries);
|
||||
}
|
||||
|
||||
static int win_result(void)
|
||||
{
|
||||
int i=inb_p(HD_STATUS);
|
||||
|
||||
if ((i & (BUSY_STAT | READY_STAT | WRERR_STAT | SEEK_STAT | ERR_STAT))
|
||||
== (READY_STAT | SEEK_STAT))
|
||||
return(0); /* ok */
|
||||
if (i&1) i=inb(HD_ERROR);
|
||||
return (1);
|
||||
}
|
||||
|
||||
static void hd_out(unsigned int drive,unsigned int nsect,unsigned int sect,
|
||||
unsigned int head,unsigned int cyl,unsigned int cmd,
|
||||
void (*intr_addr)(void))
|
||||
{
|
||||
register int port asm("dx");
|
||||
|
||||
if (drive>1 || head>15)
|
||||
panic("Trying to write bad sector");
|
||||
if (!controller_ready())
|
||||
panic("HD controller not ready");
|
||||
do_hd = intr_addr;
|
||||
outb_p(hd_info[drive].ctl,HD_CMD);
|
||||
port=HD_DATA;
|
||||
outb_p(hd_info[drive].wpcom>>2,++port);
|
||||
outb_p(nsect,++port);
|
||||
outb_p(sect,++port);
|
||||
outb_p(cyl,++port);
|
||||
outb_p(cyl>>8,++port);
|
||||
outb_p(0xA0|(drive<<4)|head,++port);
|
||||
outb(cmd,++port);
|
||||
}
|
||||
|
||||
static int drive_busy(void)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < 10000; i++)
|
||||
if (READY_STAT == (inb_p(HD_STATUS) & (BUSY_STAT|READY_STAT)))
|
||||
break;
|
||||
i = inb(HD_STATUS);
|
||||
i &= BUSY_STAT | READY_STAT | SEEK_STAT;
|
||||
if (i == READY_STAT | SEEK_STAT)
|
||||
return(0);
|
||||
printk("HD controller times out\n\r");
|
||||
return(1);
|
||||
}
|
||||
|
||||
static void reset_controller(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
outb(4,HD_CMD);
|
||||
for(i = 0; i < 100; i++) nop();
|
||||
outb(hd_info[0].ctl & 0x0f ,HD_CMD);
|
||||
if (drive_busy())
|
||||
printk("HD-controller still busy\n\r");
|
||||
if ((i = inb(HD_ERROR)) != 1)
|
||||
printk("HD-controller reset failed: %02x\n\r",i);
|
||||
}
|
||||
|
||||
static void reset_hd(int nr)
|
||||
{
|
||||
reset_controller();
|
||||
hd_out(nr,hd_info[nr].sect,hd_info[nr].sect,hd_info[nr].head-1,
|
||||
hd_info[nr].cyl,WIN_SPECIFY,&recal_intr);
|
||||
}
|
||||
|
||||
void unexpected_hd_interrupt(void)
|
||||
{
|
||||
printk("Unexpected HD interrupt\n\r");
|
||||
}
|
||||
|
||||
static void bad_rw_intr(void)
|
||||
{
|
||||
if (++CURRENT->errors >= MAX_ERRORS)
|
||||
end_request(0);
|
||||
if (CURRENT->errors > MAX_ERRORS/2)
|
||||
reset = 1;
|
||||
}
|
||||
|
||||
static void read_intr(void)
|
||||
{
|
||||
if (win_result()) {
|
||||
bad_rw_intr();
|
||||
do_hd_request();
|
||||
return;
|
||||
}
|
||||
port_read(HD_DATA,CURRENT->buffer,256);
|
||||
CURRENT->errors = 0;
|
||||
CURRENT->buffer += 512;
|
||||
CURRENT->sector++;
|
||||
if (--CURRENT->nr_sectors) {
|
||||
do_hd = &read_intr;
|
||||
return;
|
||||
}
|
||||
end_request(1);
|
||||
do_hd_request();
|
||||
}
|
||||
|
||||
static void write_intr(void)
|
||||
{
|
||||
if (win_result()) {
|
||||
bad_rw_intr();
|
||||
do_hd_request();
|
||||
return;
|
||||
}
|
||||
if (--CURRENT->nr_sectors) {
|
||||
CURRENT->sector++;
|
||||
CURRENT->buffer += 512;
|
||||
do_hd = &write_intr;
|
||||
port_write(HD_DATA,CURRENT->buffer,256);
|
||||
return;
|
||||
}
|
||||
end_request(1);
|
||||
do_hd_request();
|
||||
}
|
||||
|
||||
static void recal_intr(void)
|
||||
{
|
||||
if (win_result())
|
||||
bad_rw_intr();
|
||||
do_hd_request();
|
||||
}
|
||||
|
||||
void do_hd_request(void)
|
||||
{
|
||||
int i,r;
|
||||
unsigned int block,dev;
|
||||
unsigned int sec,head,cyl;
|
||||
unsigned int nsect;
|
||||
|
||||
INIT_REQUEST;
|
||||
dev = MINOR(CURRENT->dev);
|
||||
block = CURRENT->sector;
|
||||
if (dev >= 5*NR_HD || block+2 > hd[dev].nr_sects) {
|
||||
end_request(0);
|
||||
goto repeat;
|
||||
}
|
||||
block += hd[dev].start_sect;
|
||||
dev /= 5;
|
||||
__asm__("divl %4":"=a" (block),"=d" (sec):"0" (block),"1" (0),
|
||||
"r" (hd_info[dev].sect));
|
||||
__asm__("divl %4":"=a" (cyl),"=d" (head):"0" (block),"1" (0),
|
||||
"r" (hd_info[dev].head));
|
||||
sec++;
|
||||
nsect = CURRENT->nr_sectors;
|
||||
if (reset) {
|
||||
reset = 0;
|
||||
recalibrate = 1;
|
||||
reset_hd(CURRENT_DEV);
|
||||
return;
|
||||
}
|
||||
if (recalibrate) {
|
||||
recalibrate = 0;
|
||||
hd_out(dev,hd_info[CURRENT_DEV].sect,0,0,0,
|
||||
WIN_RESTORE,&recal_intr);
|
||||
return;
|
||||
}
|
||||
if (CURRENT->cmd == WRITE) {
|
||||
hd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
|
||||
for(i=0 ; i<3000 && !(r=inb_p(HD_STATUS)&DRQ_STAT) ; i++)
|
||||
/* nothing */ ;
|
||||
if (!r) {
|
||||
bad_rw_intr();
|
||||
goto repeat;
|
||||
}
|
||||
port_write(HD_DATA,CURRENT->buffer,256);
|
||||
} else if (CURRENT->cmd == READ) {
|
||||
hd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr);
|
||||
} else
|
||||
panic("unknown hd-command");
|
||||
}
|
||||
|
||||
void hd_init(void)
|
||||
{
|
||||
blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
|
||||
set_intr_gate(0x2E,&hd_interrupt);
|
||||
outb_p(inb_p(0x21)&0xfb,0x21);
|
||||
outb(inb_p(0xA1)&0xbf,0xA1);
|
||||
}
|
||||
Binary file not shown.
@ -1,165 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/blk_dev/ll_rw.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* This handles all read/write requests to block devices
|
||||
*/
|
||||
#include <errno.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/system.h>
|
||||
|
||||
#include "blk.h"
|
||||
|
||||
/*
|
||||
* The request-struct contains all necessary data
|
||||
* to load a nr of sectors into memory
|
||||
*/
|
||||
struct request request[NR_REQUEST];
|
||||
|
||||
/*
|
||||
* used to wait on when there are no free requests
|
||||
*/
|
||||
struct task_struct * wait_for_request = NULL;
|
||||
|
||||
/* blk_dev_struct is:
|
||||
* do_request-address
|
||||
* next-request
|
||||
*/
|
||||
struct blk_dev_struct blk_dev[NR_BLK_DEV] = {
|
||||
{ NULL, NULL }, /* no_dev */
|
||||
{ NULL, NULL }, /* dev mem */
|
||||
{ NULL, NULL }, /* dev fd */
|
||||
{ NULL, NULL }, /* dev hd */
|
||||
{ NULL, NULL }, /* dev ttyx */
|
||||
{ NULL, NULL }, /* dev tty */
|
||||
{ NULL, NULL } /* dev lp */
|
||||
};
|
||||
|
||||
static inline void lock_buffer(struct buffer_head * bh)
|
||||
{
|
||||
cli();
|
||||
while (bh->b_lock)
|
||||
sleep_on(&bh->b_wait);
|
||||
bh->b_lock=1;
|
||||
sti();
|
||||
}
|
||||
|
||||
static inline void unlock_buffer(struct buffer_head * bh)
|
||||
{
|
||||
if (!bh->b_lock)
|
||||
printk("ll_rw_block.c: buffer not locked\n\r");
|
||||
bh->b_lock = 0;
|
||||
wake_up(&bh->b_wait);
|
||||
}
|
||||
|
||||
/*
|
||||
* add-request adds a request to the linked list.
|
||||
* It disables interrupts so that it can muck with the
|
||||
* request-lists in peace.
|
||||
*/
|
||||
static void add_request(struct blk_dev_struct * dev, struct request * req)
|
||||
{
|
||||
struct request * tmp;
|
||||
|
||||
req->next = NULL;
|
||||
cli();
|
||||
if (req->bh)
|
||||
req->bh->b_dirt = 0;
|
||||
if (!(tmp = dev->current_request)) {
|
||||
dev->current_request = req;
|
||||
sti();
|
||||
(dev->request_fn)();
|
||||
return;
|
||||
}
|
||||
for ( ; tmp->next ; tmp=tmp->next)
|
||||
if ((IN_ORDER(tmp,req) ||
|
||||
!IN_ORDER(tmp,tmp->next)) &&
|
||||
IN_ORDER(req,tmp->next))
|
||||
break;
|
||||
req->next=tmp->next;
|
||||
tmp->next=req;
|
||||
sti();
|
||||
}
|
||||
|
||||
static void make_request(int major,int rw, struct buffer_head * bh)
|
||||
{
|
||||
struct request * req;
|
||||
int rw_ahead;
|
||||
|
||||
/* WRITEA/READA is special case - it is not really needed, so if the */
|
||||
/* buffer is locked, we just forget about it, else it's a normal read */
|
||||
if (rw_ahead = (rw == READA || rw == WRITEA)) {
|
||||
if (bh->b_lock)
|
||||
return;
|
||||
if (rw == READA)
|
||||
rw = READ;
|
||||
else
|
||||
rw = WRITE;
|
||||
}
|
||||
if (rw!=READ && rw!=WRITE)
|
||||
panic("Bad block dev command, must be R/W/RA/WA");
|
||||
lock_buffer(bh);
|
||||
if ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {
|
||||
unlock_buffer(bh);
|
||||
return;
|
||||
}
|
||||
repeat:
|
||||
/* we don't allow the write-requests to fill up the queue completely:
|
||||
* we want some room for reads: they take precedence. The last third
|
||||
* of the requests are only for reads.
|
||||
*/
|
||||
if (rw == READ)
|
||||
req = request+NR_REQUEST;
|
||||
else
|
||||
req = request+((NR_REQUEST*2)/3);
|
||||
/* find an empty request */
|
||||
while (--req >= request)
|
||||
if (req->dev<0)
|
||||
break;
|
||||
/* if none found, sleep on new requests: check for rw_ahead */
|
||||
if (req < request) {
|
||||
if (rw_ahead) {
|
||||
unlock_buffer(bh);
|
||||
return;
|
||||
}
|
||||
sleep_on(&wait_for_request);
|
||||
goto repeat;
|
||||
}
|
||||
/* fill up the request-info, and add it to the queue */
|
||||
req->dev = bh->b_dev;
|
||||
req->cmd = rw;
|
||||
req->errors=0;
|
||||
req->sector = bh->b_blocknr<<1;
|
||||
req->nr_sectors = 2;
|
||||
req->buffer = bh->b_data;
|
||||
req->waiting = NULL;
|
||||
req->bh = bh;
|
||||
req->next = NULL;
|
||||
add_request(major+blk_dev,req);
|
||||
}
|
||||
|
||||
void ll_rw_block(int rw, struct buffer_head * bh)
|
||||
{
|
||||
unsigned int major;
|
||||
|
||||
if ((major=MAJOR(bh->b_dev)) >= NR_BLK_DEV ||
|
||||
!(blk_dev[major].request_fn)) {
|
||||
printk("Trying to read nonexistent block-device\n\r");
|
||||
return;
|
||||
}
|
||||
make_request(major,rw,bh);
|
||||
}
|
||||
|
||||
void blk_dev_init(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<NR_REQUEST ; i++) {
|
||||
request[i].dev = -1;
|
||||
request[i].next = NULL;
|
||||
}
|
||||
}
|
||||
Binary file not shown.
@ -1,126 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/blk_drv/ramdisk.c
|
||||
*
|
||||
* Written by Theodore Ts'o, 12/2/91
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/segment.h>
|
||||
#include <asm/memory.h>
|
||||
|
||||
#define MAJOR_NR 1
|
||||
#include "blk.h"
|
||||
|
||||
char *rd_start;
|
||||
int rd_length = 0;
|
||||
|
||||
void do_rd_request(void)
|
||||
{
|
||||
int len;
|
||||
char *addr;
|
||||
|
||||
INIT_REQUEST;
|
||||
addr = rd_start + (CURRENT->sector << 9);
|
||||
len = CURRENT->nr_sectors << 9;
|
||||
if ((MINOR(CURRENT->dev) != 1) || (addr+len > rd_start+rd_length)) {
|
||||
end_request(0);
|
||||
goto repeat;
|
||||
}
|
||||
if (CURRENT-> cmd == WRITE) {
|
||||
(void ) memcpy(addr,
|
||||
CURRENT->buffer,
|
||||
len);
|
||||
} else if (CURRENT->cmd == READ) {
|
||||
(void) memcpy(CURRENT->buffer,
|
||||
addr,
|
||||
len);
|
||||
} else
|
||||
panic("unknown ramdisk-command");
|
||||
end_request(1);
|
||||
goto repeat;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns amount of memory which needs to be reserved.
|
||||
*/
|
||||
long rd_init(long mem_start, int length)
|
||||
{
|
||||
int i;
|
||||
char *cp;
|
||||
|
||||
blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
|
||||
rd_start = (char *) mem_start;
|
||||
rd_length = length;
|
||||
cp = rd_start;
|
||||
for (i=0; i < length; i++)
|
||||
*cp++ = '\0';
|
||||
return(length);
|
||||
}
|
||||
|
||||
/*
|
||||
* If the root device is the ram disk, try to load it.
|
||||
* In order to do this, the root device is originally set to the
|
||||
* floppy, and we later change it to be ram disk.
|
||||
*/
|
||||
void rd_load(void)
|
||||
{
|
||||
struct buffer_head *bh;
|
||||
struct super_block s;
|
||||
int block = 256; /* Start at block 256 */
|
||||
int i = 1;
|
||||
int nblocks;
|
||||
char *cp; /* Move pointer */
|
||||
|
||||
if (!rd_length)
|
||||
return;
|
||||
printk("Ram disk: %d bytes, starting at 0x%x\n", rd_length,
|
||||
(int) rd_start);
|
||||
if (MAJOR(ROOT_DEV) != 2)
|
||||
return;
|
||||
bh = breada(ROOT_DEV,block+1,block,block+2,-1);
|
||||
if (!bh) {
|
||||
printk("Disk error while looking for ramdisk!\n");
|
||||
return;
|
||||
}
|
||||
__asm__ volatile ("cld"); /* by wyj */
|
||||
*((struct d_super_block *) &s) = *((struct d_super_block *) bh->b_data);
|
||||
brelse(bh);
|
||||
if (s.s_magic != SUPER_MAGIC)
|
||||
/* No ram disk image present, assume normal floppy boot */
|
||||
return;
|
||||
nblocks = s.s_nzones << s.s_log_zone_size;
|
||||
if (nblocks > (rd_length >> BLOCK_SIZE_BITS)) {
|
||||
printk("Ram disk image too big! (%d blocks, %d avail)\n",
|
||||
nblocks, rd_length >> BLOCK_SIZE_BITS);
|
||||
return;
|
||||
}
|
||||
printk("Loading %d bytes into ram disk... 0000k",
|
||||
nblocks << BLOCK_SIZE_BITS);
|
||||
cp = rd_start;
|
||||
while (nblocks) {
|
||||
if (nblocks > 2)
|
||||
bh = breada(ROOT_DEV, block, block+1, block+2, -1);
|
||||
else
|
||||
bh = bread(ROOT_DEV, block);
|
||||
if (!bh) {
|
||||
printk("I/O error on block %d, aborting load\n",
|
||||
block);
|
||||
return;
|
||||
}
|
||||
(void) memcpy(cp, bh->b_data, BLOCK_SIZE);
|
||||
brelse(bh);
|
||||
printk("\010\010\010\010\010%4dk",i);
|
||||
cp += BLOCK_SIZE;
|
||||
block++;
|
||||
nblocks--;
|
||||
i++;
|
||||
}
|
||||
printk("\010\010\010\010\010done \n");
|
||||
ROOT_DEV=0x0101;
|
||||
}
|
||||
Binary file not shown.
@ -1,68 +0,0 @@
|
||||
#
|
||||
# Makefile for the FREAX-kernel character device drivers.
|
||||
#
|
||||
# Note! Dependencies are done automagically by 'make dep', which also
|
||||
# removes any old dependencies. DON'T put your own dependencies here
|
||||
# unless it's something special (ie not a .c file).
|
||||
#
|
||||
|
||||
AR =ar
|
||||
AS =as
|
||||
LD =ld
|
||||
LDFLAGS =-s -x
|
||||
CC =gcc -march=i386
|
||||
CFLAGS =-w -g -fstrength-reduce -fomit-frame-pointer -mcld \
|
||||
-finline-functions -nostdinc -fno-stack-protector -I../../include
|
||||
CPP =gcc -E -nostdinc -I../../include
|
||||
|
||||
.c.s:
|
||||
$(CC) $(CFLAGS) \
|
||||
-S -o $*.s $<
|
||||
.s.o:
|
||||
$(AS) -o $*.o $<
|
||||
.c.o:
|
||||
$(CC) $(CFLAGS) \
|
||||
-c -o $*.o $<
|
||||
|
||||
OBJS = tty_io.o console.o keyboard.2.o serial.o rs_io.o \
|
||||
tty_ioctl.o
|
||||
|
||||
chr_drv.a: $(OBJS)
|
||||
$(AR) rcs chr_drv.a $(OBJS)
|
||||
sync
|
||||
|
||||
keyboard.2.s: keyboard.S ../../include/linux/config.h
|
||||
$(CPP) -traditional keyboard.S -o keyboard.2.s
|
||||
|
||||
clean:
|
||||
rm -f core *.o *.a tmp_make keyboard.2.s
|
||||
for i in *.c;do rm -f `basename $$i .c`.s;done
|
||||
|
||||
dep:
|
||||
sed '/\#\#\# Dependencies/q' < Makefile > tmp_make
|
||||
(for i in *.c;do echo -n `echo $$i | sed 's,\.c,\.s,'`" "; \
|
||||
$(CPP) -M $$i;done) >> tmp_make
|
||||
cp tmp_make Makefile
|
||||
|
||||
### Dependencies:
|
||||
console.s console.o : console.c ../../include/linux/sched.h \
|
||||
../../include/linux/head.h ../../include/linux/fs.h \
|
||||
../../include/sys/types.h ../../include/linux/mm.h ../../include/signal.h \
|
||||
../../include/linux/tty.h ../../include/termios.h ../../include/asm/io.h \
|
||||
../../include/asm/system.h
|
||||
serial.s serial.o : serial.c ../../include/linux/tty.h ../../include/termios.h \
|
||||
../../include/linux/sched.h ../../include/linux/head.h \
|
||||
../../include/linux/fs.h ../../include/sys/types.h ../../include/linux/mm.h \
|
||||
../../include/signal.h ../../include/asm/system.h ../../include/asm/io.h
|
||||
tty_io.s tty_io.o : tty_io.c ../../include/ctype.h ../../include/errno.h \
|
||||
../../include/signal.h ../../include/sys/types.h \
|
||||
../../include/linux/sched.h ../../include/linux/head.h \
|
||||
../../include/linux/fs.h ../../include/linux/mm.h ../../include/linux/tty.h \
|
||||
../../include/termios.h ../../include/asm/segment.h \
|
||||
../../include/asm/system.h
|
||||
tty_ioctl.s tty_ioctl.o : tty_ioctl.c ../../include/errno.h ../../include/termios.h \
|
||||
../../include/linux/sched.h ../../include/linux/head.h \
|
||||
../../include/linux/fs.h ../../include/sys/types.h ../../include/linux/mm.h \
|
||||
../../include/signal.h ../../include/linux/kernel.h \
|
||||
../../include/linux/tty.h ../../include/asm/io.h \
|
||||
../../include/asm/segment.h ../../include/asm/system.h
|
||||
Binary file not shown.
@ -1,710 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/console.c
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* console.c
|
||||
*
|
||||
* This module implements the console io functions
|
||||
* 'void con_init(void)'
|
||||
* 'void con_write(struct tty_queue * queue)'
|
||||
* Hopefully this will be a rather complete VT102 implementation.
|
||||
*
|
||||
* Beeping thanks to John T Kohl.
|
||||
*/
|
||||
|
||||
/*
|
||||
* NOTE!!! We sometimes disable and enable interrupts for a short while
|
||||
* (to put a word in video IO), but this will work even for keyboard
|
||||
* interrupts. We know interrupts aren't enabled when getting a keyboard
|
||||
* interrupt, as we use trap-gates. Hopefully all is well.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Code to check for different video-cards mostly by Galen Hunt,
|
||||
* <g-hunt@ee.utah.edu>
|
||||
*/
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/tty.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/system.h>
|
||||
|
||||
/*
|
||||
* These are set up by the setup-routine at boot-time:
|
||||
*/
|
||||
|
||||
#define ORIG_X (*(unsigned char *)0x90000)
|
||||
#define ORIG_Y (*(unsigned char *)0x90001)
|
||||
#define ORIG_VIDEO_PAGE (*(unsigned short *)0x90004)
|
||||
#define ORIG_VIDEO_MODE ((*(unsigned short *)0x90006) & 0xff)
|
||||
#define ORIG_VIDEO_COLS (((*(unsigned short *)0x90006) & 0xff00) >> 8)
|
||||
#define ORIG_VIDEO_LINES (25)
|
||||
#define ORIG_VIDEO_EGA_AX (*(unsigned short *)0x90008)
|
||||
#define ORIG_VIDEO_EGA_BX (*(unsigned short *)0x9000a)
|
||||
#define ORIG_VIDEO_EGA_CX (*(unsigned short *)0x9000c)
|
||||
|
||||
#define VIDEO_TYPE_MDA 0x10 /* Monochrome Text Display */
|
||||
#define VIDEO_TYPE_CGA 0x11 /* CGA Display */
|
||||
#define VIDEO_TYPE_EGAM 0x20 /* EGA/VGA in Monochrome Mode */
|
||||
#define VIDEO_TYPE_EGAC 0x21 /* EGA/VGA in Color Mode */
|
||||
|
||||
#define NPAR 16
|
||||
|
||||
extern void keyboard_interrupt(void);
|
||||
|
||||
static unsigned char video_type; /* Type of display being used */
|
||||
static unsigned long video_num_columns; /* Number of text columns */
|
||||
static unsigned long video_size_row; /* Bytes per row */
|
||||
static unsigned long video_num_lines; /* Number of test lines */
|
||||
static unsigned char video_page; /* Initial video page */
|
||||
static unsigned long video_mem_start; /* Start of video RAM */
|
||||
static unsigned long video_mem_end; /* End of video RAM (sort of) */
|
||||
static unsigned short video_port_reg; /* Video register select port */
|
||||
static unsigned short video_port_val; /* Video register value port */
|
||||
static unsigned short video_erase_char; /* Char+Attrib to erase with */
|
||||
|
||||
static unsigned long origin; /* Used for EGA/VGA fast scroll */
|
||||
static unsigned long scr_end; /* Used for EGA/VGA fast scroll */
|
||||
static unsigned long pos;
|
||||
static unsigned long x,y;
|
||||
static unsigned long top,bottom;
|
||||
static unsigned long state=0;
|
||||
static unsigned long npar,par[NPAR];
|
||||
static unsigned long ques=0;
|
||||
static unsigned char attr=0x07;
|
||||
|
||||
static void sysbeep(void);
|
||||
|
||||
/*
|
||||
* this is what the terminal answers to a ESC-Z or csi0c
|
||||
* query (= vt100 response).
|
||||
*/
|
||||
#define RESPONSE "\033[?1;2c"
|
||||
|
||||
/* NOTE! gotoxy thinks x==video_num_columns is ok */
|
||||
static inline void gotoxy(unsigned int new_x,unsigned int new_y)
|
||||
{
|
||||
if (new_x > video_num_columns || new_y >= video_num_lines)
|
||||
return;
|
||||
x=new_x;
|
||||
y=new_y;
|
||||
pos=origin + y*video_size_row + (x<<1);
|
||||
}
|
||||
|
||||
static inline void set_origin(void)
|
||||
{
|
||||
cli();
|
||||
outb_p(12, video_port_reg);
|
||||
outb_p(0xff&((origin-video_mem_start)>>9), video_port_val);
|
||||
outb_p(13, video_port_reg);
|
||||
outb_p(0xff&((origin-video_mem_start)>>1), video_port_val);
|
||||
sti();
|
||||
}
|
||||
|
||||
static void scrup(void)
|
||||
{
|
||||
if (video_type == VIDEO_TYPE_EGAC || video_type == VIDEO_TYPE_EGAM)
|
||||
{
|
||||
if (!top && bottom == video_num_lines) {
|
||||
origin += video_size_row;
|
||||
pos += video_size_row;
|
||||
scr_end += video_size_row;
|
||||
if (scr_end > video_mem_end) {
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"movsl\n\t"
|
||||
"movl video_num_columns,%1\n\t"
|
||||
"rep\n\t"
|
||||
"stosw"
|
||||
::"a" (video_erase_char),
|
||||
"c" ((video_num_lines-1)*video_num_columns>>1),
|
||||
"D" (video_mem_start),
|
||||
"S" (origin)
|
||||
);
|
||||
scr_end -= origin-video_mem_start;
|
||||
pos -= origin-video_mem_start;
|
||||
origin = video_mem_start;
|
||||
} else {
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"stosw"
|
||||
::"a" (video_erase_char),
|
||||
"c" (video_num_columns),
|
||||
"D" (scr_end-video_size_row)
|
||||
);
|
||||
}
|
||||
set_origin();
|
||||
} else {
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"movsl\n\t"
|
||||
"movl video_num_columns,%%ecx\n\t"
|
||||
"rep\n\t"
|
||||
"stosw"
|
||||
::"a" (video_erase_char),
|
||||
"c" ((bottom-top-1)*video_num_columns>>1),
|
||||
"D" (origin+video_size_row*top),
|
||||
"S" (origin+video_size_row*(top+1))
|
||||
);
|
||||
}
|
||||
}
|
||||
else /* Not EGA/VGA */
|
||||
{
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"movsl\n\t"
|
||||
"movl video_num_columns,%%ecx\n\t"
|
||||
"rep\n\t"
|
||||
"stosw"
|
||||
::"a" (video_erase_char),
|
||||
"c" ((bottom-top-1)*video_num_columns>>1),
|
||||
"D" (origin+video_size_row*top),
|
||||
"S" (origin+video_size_row*(top+1))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
static void scrdown(void)
|
||||
{
|
||||
if (video_type == VIDEO_TYPE_EGAC || video_type == VIDEO_TYPE_EGAM)
|
||||
{
|
||||
__asm__("std\n\t"
|
||||
"rep\n\t"
|
||||
"movsl\n\t"
|
||||
"addl $2,%%edi\n\t" /* %edi has been decremented by 4 */
|
||||
"movl video_num_columns,%%ecx\n\t"
|
||||
"rep\n\t"
|
||||
"stosw"
|
||||
::"a" (video_erase_char),
|
||||
"c" ((bottom-top-1)*video_num_columns>>1),
|
||||
"D" (origin+video_size_row*bottom-4),
|
||||
"S" (origin+video_size_row*(bottom-1)-4)
|
||||
);
|
||||
}
|
||||
else /* Not EGA/VGA */
|
||||
{
|
||||
__asm__("std\n\t"
|
||||
"rep\n\t"
|
||||
"movsl\n\t"
|
||||
"addl $2,%%edi\n\t" /* %edi has been decremented by 4 */
|
||||
"movl video_num_columns,%%ecx\n\t"
|
||||
"rep\n\t"
|
||||
"stosw"
|
||||
::"a" (video_erase_char),
|
||||
"c" ((bottom-top-1)*video_num_columns>>1),
|
||||
"D" (origin+video_size_row*bottom-4),
|
||||
"S" (origin+video_size_row*(bottom-1)-4)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
static void lf(void)
|
||||
{
|
||||
if (y+1<bottom) {
|
||||
y++;
|
||||
pos += video_size_row;
|
||||
return;
|
||||
}
|
||||
scrup();
|
||||
}
|
||||
|
||||
static void ri(void)
|
||||
{
|
||||
if (y>top) {
|
||||
y--;
|
||||
pos -= video_size_row;
|
||||
return;
|
||||
}
|
||||
scrdown();
|
||||
}
|
||||
|
||||
static void cr(void)
|
||||
{
|
||||
pos -= x<<1;
|
||||
x=0;
|
||||
}
|
||||
|
||||
static void del(void)
|
||||
{
|
||||
if (x) {
|
||||
pos -= 2;
|
||||
x--;
|
||||
*(unsigned short *)pos = video_erase_char;
|
||||
}
|
||||
}
|
||||
|
||||
static void csi_J(int par)
|
||||
{
|
||||
long count __asm__("cx");
|
||||
long start __asm__("di");
|
||||
|
||||
switch (par) {
|
||||
case 0: /* erase from cursor to end of display */
|
||||
count = (scr_end-pos)>>1;
|
||||
start = pos;
|
||||
break;
|
||||
case 1: /* erase from start to cursor */
|
||||
count = (pos-origin)>>1;
|
||||
start = origin;
|
||||
break;
|
||||
case 2: /* erase whole display */
|
||||
count = video_num_columns * video_num_lines;
|
||||
start = origin;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"stosw\n\t"
|
||||
::"c" (count),
|
||||
"D" (start),"a" (video_erase_char)
|
||||
);
|
||||
}
|
||||
|
||||
static void csi_K(int par)
|
||||
{
|
||||
long count __asm__("cx");
|
||||
long start __asm__("di");
|
||||
|
||||
switch (par) {
|
||||
case 0: /* erase from cursor to end of line */
|
||||
if (x>=video_num_columns)
|
||||
return;
|
||||
count = video_num_columns-x;
|
||||
start = pos;
|
||||
break;
|
||||
case 1: /* erase from start of line to cursor */
|
||||
start = pos - (x<<1);
|
||||
count = (x<video_num_columns)?x:video_num_columns;
|
||||
break;
|
||||
case 2: /* erase whole line */
|
||||
start = pos - (x<<1);
|
||||
count = video_num_columns;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
__asm__("cld\n\t"
|
||||
"rep\n\t"
|
||||
"stosw\n\t"
|
||||
::"c" (count),
|
||||
"D" (start),"a" (video_erase_char)
|
||||
);
|
||||
}
|
||||
|
||||
void csi_m(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0;i<=npar;i++)
|
||||
switch (par[i]) {
|
||||
case 0:attr=0x07;break;
|
||||
case 1:attr=0x0f;break;
|
||||
case 4:attr=0x0f;break;
|
||||
case 7:attr=0x70;break;
|
||||
case 27:attr=0x07;break;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void set_cursor(void)
|
||||
{
|
||||
cli();
|
||||
outb_p(14, video_port_reg);
|
||||
outb_p(0xff&((pos-video_mem_start)>>9), video_port_val);
|
||||
outb_p(15, video_port_reg);
|
||||
outb_p(0xff&((pos-video_mem_start)>>1), video_port_val);
|
||||
sti();
|
||||
}
|
||||
|
||||
static void respond(struct tty_struct * tty)
|
||||
{
|
||||
char * p = RESPONSE;
|
||||
|
||||
cli();
|
||||
while (*p) {
|
||||
PUTCH(*p,tty->read_q);
|
||||
p++;
|
||||
}
|
||||
sti();
|
||||
copy_to_cooked(tty);
|
||||
}
|
||||
|
||||
static void insert_char(void)
|
||||
{
|
||||
int i=x;
|
||||
unsigned short tmp, old = video_erase_char;
|
||||
unsigned short * p = (unsigned short *) pos;
|
||||
|
||||
while (i++<video_num_columns) {
|
||||
tmp=*p;
|
||||
*p=old;
|
||||
old=tmp;
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
static void insert_line(void)
|
||||
{
|
||||
int oldtop,oldbottom;
|
||||
|
||||
oldtop=top;
|
||||
oldbottom=bottom;
|
||||
top=y;
|
||||
bottom = video_num_lines;
|
||||
scrdown();
|
||||
top=oldtop;
|
||||
bottom=oldbottom;
|
||||
}
|
||||
|
||||
static void delete_char(void)
|
||||
{
|
||||
int i;
|
||||
unsigned short * p = (unsigned short *) pos;
|
||||
|
||||
if (x>=video_num_columns)
|
||||
return;
|
||||
i = x;
|
||||
while (++i < video_num_columns) {
|
||||
*p = *(p+1);
|
||||
p++;
|
||||
}
|
||||
*p = video_erase_char;
|
||||
}
|
||||
|
||||
static void delete_line(void)
|
||||
{
|
||||
int oldtop,oldbottom;
|
||||
|
||||
oldtop=top;
|
||||
oldbottom=bottom;
|
||||
top=y;
|
||||
bottom = video_num_lines;
|
||||
scrup();
|
||||
top=oldtop;
|
||||
bottom=oldbottom;
|
||||
}
|
||||
|
||||
static void csi_at(unsigned int nr)
|
||||
{
|
||||
if (nr > video_num_columns)
|
||||
nr = video_num_columns;
|
||||
else if (!nr)
|
||||
nr = 1;
|
||||
while (nr--)
|
||||
insert_char();
|
||||
}
|
||||
|
||||
static void csi_L(unsigned int nr)
|
||||
{
|
||||
if (nr > video_num_lines)
|
||||
nr = video_num_lines;
|
||||
else if (!nr)
|
||||
nr = 1;
|
||||
while (nr--)
|
||||
insert_line();
|
||||
}
|
||||
|
||||
static void csi_P(unsigned int nr)
|
||||
{
|
||||
if (nr > video_num_columns)
|
||||
nr = video_num_columns;
|
||||
else if (!nr)
|
||||
nr = 1;
|
||||
while (nr--)
|
||||
delete_char();
|
||||
}
|
||||
|
||||
static void csi_M(unsigned int nr)
|
||||
{
|
||||
if (nr > video_num_lines)
|
||||
nr = video_num_lines;
|
||||
else if (!nr)
|
||||
nr=1;
|
||||
while (nr--)
|
||||
delete_line();
|
||||
}
|
||||
|
||||
static int saved_x=0;
|
||||
static int saved_y=0;
|
||||
|
||||
static void save_cur(void)
|
||||
{
|
||||
saved_x=x;
|
||||
saved_y=y;
|
||||
}
|
||||
|
||||
static void restore_cur(void)
|
||||
{
|
||||
gotoxy(saved_x, saved_y);
|
||||
}
|
||||
|
||||
void con_write(struct tty_struct * tty)
|
||||
{
|
||||
int nr;
|
||||
char c;
|
||||
|
||||
nr = CHARS(tty->write_q);
|
||||
while (nr--) {
|
||||
GETCH(tty->write_q,c);
|
||||
switch(state) {
|
||||
case 0:
|
||||
if (c>31 && c<127) {
|
||||
if (x>=video_num_columns) {
|
||||
x -= video_num_columns;
|
||||
pos -= video_size_row;
|
||||
lf();
|
||||
}
|
||||
__asm__("movb attr,%%ah\n\t"
|
||||
"movw %%ax,%1\n\t"
|
||||
::"a" (c),"m" (*(short *)pos)
|
||||
);
|
||||
pos += 2;
|
||||
x++;
|
||||
} else if (c==27)
|
||||
state=1;
|
||||
else if (c==10 || c==11 || c==12)
|
||||
lf();
|
||||
else if (c==13)
|
||||
cr();
|
||||
else if (c==ERASE_CHAR(tty))
|
||||
del();
|
||||
else if (c==8) {
|
||||
if (x) {
|
||||
x--;
|
||||
pos -= 2;
|
||||
}
|
||||
} else if (c==9) {
|
||||
c=8-(x&7);
|
||||
x += c;
|
||||
pos += c<<1;
|
||||
if (x>video_num_columns) {
|
||||
x -= video_num_columns;
|
||||
pos -= video_size_row;
|
||||
lf();
|
||||
}
|
||||
c=9;
|
||||
} else if (c==7)
|
||||
sysbeep();
|
||||
break;
|
||||
case 1:
|
||||
state=0;
|
||||
if (c=='[')
|
||||
state=2;
|
||||
else if (c=='E')
|
||||
gotoxy(0,y+1);
|
||||
else if (c=='M')
|
||||
ri();
|
||||
else if (c=='D')
|
||||
lf();
|
||||
else if (c=='Z')
|
||||
respond(tty);
|
||||
else if (x=='7')
|
||||
save_cur();
|
||||
else if (x=='8')
|
||||
restore_cur();
|
||||
break;
|
||||
case 2:
|
||||
for(npar=0;npar<NPAR;npar++)
|
||||
par[npar]=0;
|
||||
npar=0;
|
||||
state=3;
|
||||
if (ques=(c=='?'))
|
||||
break;
|
||||
case 3:
|
||||
if (c==';' && npar<NPAR-1) {
|
||||
npar++;
|
||||
break;
|
||||
} else if (c>='0' && c<='9') {
|
||||
par[npar]=10*par[npar]+c-'0';
|
||||
break;
|
||||
} else state=4;
|
||||
case 4:
|
||||
state=0;
|
||||
switch(c) {
|
||||
case 'G': case '`':
|
||||
if (par[0]) par[0]--;
|
||||
gotoxy(par[0],y);
|
||||
break;
|
||||
case 'A':
|
||||
if (!par[0]) par[0]++;
|
||||
gotoxy(x,y-par[0]);
|
||||
break;
|
||||
case 'B': case 'e':
|
||||
if (!par[0]) par[0]++;
|
||||
gotoxy(x,y+par[0]);
|
||||
break;
|
||||
case 'C': case 'a':
|
||||
if (!par[0]) par[0]++;
|
||||
gotoxy(x+par[0],y);
|
||||
break;
|
||||
case 'D':
|
||||
if (!par[0]) par[0]++;
|
||||
gotoxy(x-par[0],y);
|
||||
break;
|
||||
case 'E':
|
||||
if (!par[0]) par[0]++;
|
||||
gotoxy(0,y+par[0]);
|
||||
break;
|
||||
case 'F':
|
||||
if (!par[0]) par[0]++;
|
||||
gotoxy(0,y-par[0]);
|
||||
break;
|
||||
case 'd':
|
||||
if (par[0]) par[0]--;
|
||||
gotoxy(x,par[0]);
|
||||
break;
|
||||
case 'H': case 'f':
|
||||
if (par[0]) par[0]--;
|
||||
if (par[1]) par[1]--;
|
||||
gotoxy(par[1],par[0]);
|
||||
break;
|
||||
case 'J':
|
||||
csi_J(par[0]);
|
||||
break;
|
||||
case 'K':
|
||||
csi_K(par[0]);
|
||||
break;
|
||||
case 'L':
|
||||
csi_L(par[0]);
|
||||
break;
|
||||
case 'M':
|
||||
csi_M(par[0]);
|
||||
break;
|
||||
case 'P':
|
||||
csi_P(par[0]);
|
||||
break;
|
||||
case '@':
|
||||
csi_at(par[0]);
|
||||
break;
|
||||
case 'm':
|
||||
csi_m();
|
||||
break;
|
||||
case 'r':
|
||||
if (par[0]) par[0]--;
|
||||
if (!par[1]) par[1] = video_num_lines;
|
||||
if (par[0] < par[1] &&
|
||||
par[1] <= video_num_lines) {
|
||||
top=par[0];
|
||||
bottom=par[1];
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
save_cur();
|
||||
break;
|
||||
case 'u':
|
||||
restore_cur();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
set_cursor();
|
||||
}
|
||||
|
||||
/*
|
||||
* void con_init(void);
|
||||
*
|
||||
* This routine initalizes console interrupts, and does nothing
|
||||
* else. If you want the screen to clear, call tty_write with
|
||||
* the appropriate escape-sequece.
|
||||
*
|
||||
* Reads the information preserved by setup.s to determine the current display
|
||||
* type and sets everything accordingly.
|
||||
*/
|
||||
void con_init(void)
|
||||
{
|
||||
register unsigned char a;
|
||||
char *display_desc = "????";
|
||||
char *display_ptr;
|
||||
|
||||
video_num_columns = ORIG_VIDEO_COLS;
|
||||
video_size_row = video_num_columns * 2;
|
||||
video_num_lines = ORIG_VIDEO_LINES;
|
||||
video_page = ORIG_VIDEO_PAGE;
|
||||
video_erase_char = 0x0720;
|
||||
|
||||
if (ORIG_VIDEO_MODE == 7) /* Is this a monochrome display? */
|
||||
{
|
||||
video_mem_start = 0xb0000;
|
||||
video_port_reg = 0x3b4;
|
||||
video_port_val = 0x3b5;
|
||||
if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10)
|
||||
{
|
||||
video_type = VIDEO_TYPE_EGAM;
|
||||
video_mem_end = 0xb8000;
|
||||
display_desc = "EGAm";
|
||||
}
|
||||
else
|
||||
{
|
||||
video_type = VIDEO_TYPE_MDA;
|
||||
video_mem_end = 0xb2000;
|
||||
display_desc = "*MDA";
|
||||
}
|
||||
}
|
||||
else /* If not, it is color. */
|
||||
{
|
||||
video_mem_start = 0xb8000;
|
||||
video_port_reg = 0x3d4;
|
||||
video_port_val = 0x3d5;
|
||||
if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10)
|
||||
{
|
||||
video_type = VIDEO_TYPE_EGAC;
|
||||
video_mem_end = 0xbc000;
|
||||
display_desc = "EGAc";
|
||||
}
|
||||
else
|
||||
{
|
||||
video_type = VIDEO_TYPE_CGA;
|
||||
video_mem_end = 0xba000;
|
||||
display_desc = "*CGA";
|
||||
}
|
||||
}
|
||||
|
||||
/* Let the user known what kind of display driver we are using */
|
||||
|
||||
display_ptr = ((char *)video_mem_start) + video_size_row - 8;
|
||||
while (*display_desc)
|
||||
{
|
||||
*display_ptr++ = *display_desc++;
|
||||
display_ptr++;
|
||||
}
|
||||
|
||||
/* Initialize the variables used for scrolling (mostly EGA/VGA) */
|
||||
|
||||
origin = video_mem_start;
|
||||
scr_end = video_mem_start + video_num_lines * video_size_row;
|
||||
top = 0;
|
||||
bottom = video_num_lines;
|
||||
|
||||
gotoxy(ORIG_X,ORIG_Y);
|
||||
set_trap_gate(0x21,&keyboard_interrupt);
|
||||
outb_p(inb_p(0x21)&0xfd,0x21);
|
||||
a=inb_p(0x61);
|
||||
outb_p(a|0x80,0x61);
|
||||
outb(a,0x61);
|
||||
}
|
||||
/* from bsd-net-2: */
|
||||
|
||||
void sysbeepstop(void)
|
||||
{
|
||||
/* disable counter 2 */
|
||||
outb(inb_p(0x61)&0xFC, 0x61);
|
||||
}
|
||||
|
||||
int beepcount = 0;
|
||||
|
||||
static void sysbeep(void)
|
||||
{
|
||||
/* enable counter 2 */
|
||||
outb_p(inb_p(0x61)|3, 0x61);
|
||||
/* set command for counter 2, 2 byte write */
|
||||
outb_p(0xB6, 0x43);
|
||||
/* send 0x637 for 750 HZ */
|
||||
outb_p(0x37, 0x42);
|
||||
outb(0x06, 0x42);
|
||||
/* 1/8 second */
|
||||
beepcount = HZ/8;
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
@ -1,466 +0,0 @@
|
||||
# 1 "keyboard.S"
|
||||
# 1 "<built-in>"
|
||||
# 1 "<command-line>"
|
||||
# 1 "keyboard.S"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# 1 "../../include/linux/config.h" 1
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# 36 "../../include/linux/config.h"
|
||||
|
||||
# 47 "../../include/linux/config.h"
|
||||
|
||||
# 14 "keyboard.S" 2
|
||||
|
||||
.text
|
||||
.globl keyboard_interrupt
|
||||
|
||||
|
||||
|
||||
|
||||
size = 1024
|
||||
|
||||
head = 4
|
||||
tail = 8
|
||||
proc_list = 12
|
||||
buf = 16
|
||||
|
||||
mode: .byte 0
|
||||
leds: .byte 2
|
||||
e0: .byte 0
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
keyboard_interrupt:
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
push %ds
|
||||
push %es
|
||||
movl $0x10,%eax
|
||||
mov %ax,%ds
|
||||
mov %ax,%es
|
||||
xor %al,%al
|
||||
inb $0x60,%al
|
||||
cmpb $0xe0,%al
|
||||
je set_e0
|
||||
cmpb $0xe1,%al
|
||||
je set_e1
|
||||
call key_table(,%eax,4)
|
||||
movb $0,e0
|
||||
e0_e1: inb $0x61,%al
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: orb $0x80,%al
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: outb %al,$0x61
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: andb $0x7F,%al
|
||||
outb %al,$0x61
|
||||
movb $0x20,%al
|
||||
outb %al,$0x20
|
||||
pushl $0
|
||||
call do_tty_interrupt
|
||||
addl $4,%esp
|
||||
pop %es
|
||||
pop %ds
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %ebx
|
||||
popl %eax
|
||||
iret
|
||||
set_e0: movb $1,e0
|
||||
jmp e0_e1
|
||||
set_e1: movb $2,e0
|
||||
jmp e0_e1
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
put_queue:
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl table_list,%edx # read-queue for console
|
||||
movl head(%edx),%ecx
|
||||
1: movb %al,buf(%edx,%ecx)
|
||||
incl %ecx
|
||||
andl $size-1,%ecx
|
||||
cmpl tail(%edx),%ecx # buffer full - discard everything
|
||||
je 3f
|
||||
shrdl $8,%ebx,%eax
|
||||
je 2f
|
||||
shrl $8,%ebx
|
||||
jmp 1b
|
||||
2: movl %ecx,head(%edx)
|
||||
movl proc_list(%edx),%ecx
|
||||
testl %ecx,%ecx
|
||||
je 3f
|
||||
movl $0,(%ecx)
|
||||
3: popl %edx
|
||||
popl %ecx
|
||||
ret
|
||||
|
||||
ctrl: movb $0x04,%al
|
||||
jmp 1f
|
||||
alt: movb $0x10,%al
|
||||
1: cmpb $0,e0
|
||||
je 2f
|
||||
addb %al,%al
|
||||
2: orb %al,mode
|
||||
ret
|
||||
unctrl: movb $0x04,%al
|
||||
jmp 1f
|
||||
unalt: movb $0x10,%al
|
||||
1: cmpb $0,e0
|
||||
je 2f
|
||||
addb %al,%al
|
||||
2: notb %al
|
||||
andb %al,mode
|
||||
ret
|
||||
|
||||
lshift:
|
||||
orb $0x01,mode
|
||||
ret
|
||||
unlshift:
|
||||
andb $0xfe,mode
|
||||
ret
|
||||
rshift:
|
||||
orb $0x02,mode
|
||||
ret
|
||||
unrshift:
|
||||
andb $0xfd,mode
|
||||
ret
|
||||
|
||||
caps: testb $0x80,mode
|
||||
jne 1f
|
||||
xorb $4,leds
|
||||
xorb $0x40,mode
|
||||
orb $0x80,mode
|
||||
set_leds:
|
||||
call kb_wait
|
||||
movb $0xed,%al
|
||||
outb %al,$0x60
|
||||
call kb_wait
|
||||
movb leds,%al
|
||||
outb %al,$0x60
|
||||
ret
|
||||
uncaps: andb $0x7f,mode
|
||||
ret
|
||||
scroll:
|
||||
xorb $1,leds
|
||||
jmp set_leds
|
||||
num: xorb $2,leds
|
||||
jmp set_leds
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
cursor:
|
||||
subb $0x47,%al
|
||||
jb 1f
|
||||
cmpb $12,%al
|
||||
ja 1f
|
||||
jne cur2
|
||||
testb $0x0c,mode
|
||||
je cur2
|
||||
testb $0x30,mode
|
||||
jne reboot
|
||||
cur2: cmpb $0x01,e0
|
||||
je cur
|
||||
testb $0x02,leds
|
||||
je cur
|
||||
testb $0x03,mode
|
||||
jne cur
|
||||
xorl %ebx,%ebx
|
||||
movb num_table(%eax),%al
|
||||
jmp put_queue
|
||||
1: ret
|
||||
|
||||
cur: movb cur_table(%eax),%al
|
||||
cmpb $'9,%al
|
||||
ja ok_cur
|
||||
movb $'~,%ah
|
||||
ok_cur: shll $16,%eax
|
||||
movw $0x5b1b,%ax
|
||||
xorl %ebx,%ebx
|
||||
jmp put_queue
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
num_table:
|
||||
.ascii "789 456 1230,"
|
||||
|
||||
cur_table:
|
||||
.ascii "HA5 DGC YB623"
|
||||
|
||||
|
||||
|
||||
|
||||
func:
|
||||
pushl %eax
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
call show_stat
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %eax
|
||||
subb $0x3B,%al
|
||||
jb end_func
|
||||
cmpb $9,%al
|
||||
jbe ok_func
|
||||
subb $18,%al
|
||||
cmpb $10,%al
|
||||
jb end_func
|
||||
cmpb $11,%al
|
||||
ja end_func
|
||||
ok_func:
|
||||
cmpl $4,%ecx
|
||||
jl end_func
|
||||
movl func_table(,%eax,4),%eax
|
||||
xorl %ebx,%ebx
|
||||
jmp put_queue
|
||||
end_func:
|
||||
ret
|
||||
|
||||
|
||||
|
||||
|
||||
func_table:
|
||||
.long 0x415b5b1b,0x425b5b1b,0x435b5b1b,0x445b5b1b
|
||||
.long 0x455b5b1b,0x465b5b1b,0x475b5b1b,0x485b5b1b
|
||||
.long 0x495b5b1b,0x4a5b5b1b,0x4b5b5b1b,0x4c5b5b1b
|
||||
|
||||
# 294 "keyboard.S"
|
||||
|
||||
key_map:
|
||||
.byte 0,27
|
||||
.ascii "1234567890-="
|
||||
.byte 127,9
|
||||
.ascii "qwertyuiop[]"
|
||||
.byte 13,0
|
||||
.ascii "asdfghjkl;'"
|
||||
.byte '`,0
|
||||
.ascii "\\zxcvbnm,./"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0
|
||||
.byte '-,0,0,0,'+
|
||||
.byte 0,0,0,0,0,0,0
|
||||
.byte '<
|
||||
.fill 10,1,0
|
||||
|
||||
|
||||
shift_map:
|
||||
.byte 0,27
|
||||
.ascii "!@#$%^&*()_+"
|
||||
.byte 127,9
|
||||
.ascii "QWERTYUIOP{}"
|
||||
.byte 13,0
|
||||
.ascii "ASDFGHJKL:\""
|
||||
.byte '~,0
|
||||
.ascii "|ZXCVBNM<>?"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0
|
||||
.byte '-,0,0,0,'+
|
||||
.byte 0,0,0,0,0,0,0
|
||||
.byte '>
|
||||
.fill 10,1,0
|
||||
|
||||
alt_map:
|
||||
.byte 0,0
|
||||
.ascii "\0@\0$\0\0{[]}\\\0"
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte '~,13,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0,0,0
|
||||
.fill 16,1,0
|
||||
.byte 0,0,0,0,0
|
||||
.byte 0,0,0,0,0,0,0
|
||||
.byte '|
|
||||
.fill 10,1,0
|
||||
|
||||
# 449 "keyboard.S"
|
||||
|
||||
|
||||
|
||||
|
||||
do_self:
|
||||
lea alt_map,%ebx
|
||||
testb $0x20,mode
|
||||
jne 1f
|
||||
lea shift_map,%ebx
|
||||
testb $0x03,mode
|
||||
jne 1f
|
||||
lea key_map,%ebx
|
||||
1: movb (%ebx,%eax),%al
|
||||
orb %al,%al
|
||||
je none
|
||||
testb $0x4c,mode
|
||||
je 2f
|
||||
cmpb $'a,%al
|
||||
jb 2f
|
||||
cmpb $'},%al
|
||||
ja 2f
|
||||
subb $32,%al
|
||||
2: testb $0x0c,mode
|
||||
je 3f
|
||||
cmpb $64,%al
|
||||
jb 3f
|
||||
cmpb $64+32,%al
|
||||
jae 3f
|
||||
subb $64,%al
|
||||
3: testb $0x10,mode
|
||||
je 4f
|
||||
orb $0x80,%al
|
||||
4: andl $0xff,%eax
|
||||
xorl %ebx,%ebx
|
||||
call put_queue
|
||||
none: ret
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
minus: cmpb $1,e0
|
||||
jne do_self
|
||||
movl $'/,%eax
|
||||
xorl %ebx,%ebx
|
||||
jmp put_queue
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
key_table:
|
||||
.long none,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,ctrl,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,lshift,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,do_self,do_self,do_self
|
||||
.long do_self,minus,rshift,do_self
|
||||
.long alt,do_self,caps,func
|
||||
.long func,func,func,func
|
||||
.long func,func,func,func
|
||||
.long func,num,scroll,cursor
|
||||
.long cursor,cursor,do_self,cursor
|
||||
.long cursor,cursor,do_self,cursor
|
||||
.long cursor,cursor,cursor,cursor
|
||||
.long none,none,do_self,func
|
||||
.long func,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,unctrl,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,unlshift,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,unrshift,none
|
||||
.long unalt,none,uncaps,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
.long none,none,none,none
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
kb_wait:
|
||||
pushl %eax
|
||||
1: inb $0x64,%al
|
||||
testb $0x02,%al
|
||||
jne 1b
|
||||
popl %eax
|
||||
ret
|
||||
|
||||
|
||||
|
||||
|
||||
reboot:
|
||||
call kb_wait
|
||||
movw $0x1234,0x472
|
||||
movb $0xfc,%al
|
||||
outb %al,$0x64
|
||||
die: jmp die
|
||||
@ -1,588 +0,0 @@
|
||||
/*
|
||||
* linux/kernel/keyboard.S
|
||||
*
|
||||
* (C) 1991 Linus Torvalds
|
||||
*/
|
||||
|
||||
/*
|
||||
* Thanks to Alfred Leung for US keyboard patches
|
||||
* Wolfgang Thiel for German keyboard patches
|
||||
* Marc Corsini for the French keyboard
|
||||
*/
|
||||
|
||||
#include <linux/config.h>
|
||||
|
||||
.text
|
||||
.globl keyboard_interrupt
|
||||
|
||||
/*
|
||||
* these are for the keyboard read functions
|
||||
*/
|
||||
size = 1024 /* must be a power of two ! And MUST be the same
|
||||
as in tty_io.c !!!! */
|
||||
head = 4
|
||||
tail = 8
|
||||
proc_list = 12
|
||||
buf = 16
|
||||
|
||||
mode: .byte 0 /* caps, alt, ctrl and shift mode */
|
||||
leds: .byte 2 /* num-lock, caps, scroll-lock mode (nom-lock on) */
|
||||
e0: .byte 0
|
||||
|
||||
/*
|
||||
* con_int is the real interrupt routine that reads the
|
||||
* keyboard scan-code and converts it into the appropriate
|
||||
* ascii character(s).
|
||||
*/
|
||||
keyboard_interrupt:
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
push %ds
|
||||
push %es
|
||||
movl $0x10,%eax
|
||||
mov %ax,%ds
|
||||
mov %ax,%es
|
||||
xor %al,%al /* %eax is scan code */
|
||||
inb $0x60,%al
|
||||
cmpb $0xe0,%al
|
||||
je set_e0
|
||||
cmpb $0xe1,%al
|
||||
je set_e1
|
||||
call key_table(,%eax,4)
|
||||
movb $0,e0
|
||||
e0_e1: inb $0x61,%al
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: orb $0x80,%al
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: outb %al,$0x61
|
||||
jmp 1f
|
||||
1: jmp 1f
|
||||
1: andb $0x7F,%al
|
||||
outb %al,$0x61
|
||||
movb $0x20,%al
|
||||
outb %al,$0x20
|
||||
pushl $0
|
||||
call do_tty_interrupt
|
||||
addl $4,%esp
|
||||
pop %es
|
||||
pop %ds
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %ebx
|
||||
popl %eax
|
||||
iret
|
||||
set_e0: movb $1,e0
|
||||
jmp e0_e1
|
||||
set_e1: movb $2,e0
|
||||
jmp e0_e1
|
||||
|
||||
/*
|
||||
* This routine fills the buffer with max 8 bytes, taken from
|
||||
* %ebx:%eax. (%edx is high). The bytes are written in the
|
||||
* order %al,%ah,%eal,%eah,%bl,%bh ... until %eax is zero.
|
||||
*/
|
||||
put_queue:
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl table_list,%edx # read-queue for console
|
||||
movl head(%edx),%ecx
|
||||
1: movb %al,buf(%edx,%ecx)
|
||||
incl %ecx
|
||||
andl $size-1,%ecx
|
||||
cmpl tail(%edx),%ecx # buffer full - discard everything
|
||||
je 3f
|
||||
shrdl $8,%ebx,%eax
|
||||
je 2f
|
||||
shrl $8,%ebx
|
||||
jmp 1b
|
||||
2: movl %ecx,head(%edx)
|
||||
movl proc_list(%edx),%ecx
|
||||
testl %ecx,%ecx
|
||||
je 3f
|
||||
movl $0,(%ecx)
|
||||
3: popl %edx
|
||||
popl %ecx
|
||||
ret
|
||||
|
||||
ctrl: movb $0x04,%al
|
||||
jmp 1f
|
||||
alt: movb $0x10,%al
|
||||
1: cmpb $0,e0
|
||||
je 2f
|
||||
addb %al,%al
|
||||
2: orb %al,mode
|
||||
ret
|
||||
unctrl: movb $0x04,%al
|
||||
jmp 1f
|
||||
unalt: movb $0x10,%al
|
||||
1: cmpb $0,e0
|
||||
je 2f
|
||||
addb %al,%al
|
||||
2: notb %al
|
||||
andb %al,mode
|
||||
ret
|
||||
|
||||
lshift:
|
||||
orb $0x01,mode
|
||||
ret
|
||||
unlshift:
|
||||
andb $0xfe,mode
|
||||
ret
|
||||
rshift:
|
||||
orb $0x02,mode
|
||||
ret
|
||||
unrshift:
|
||||
andb $0xfd,mode
|
||||
ret
|
||||
|
||||
caps: testb $0x80,mode
|
||||
jne 1f
|
||||
xorb $4,leds
|
||||
xorb $0x40,mode
|
||||
orb $0x80,mode
|
||||
set_leds:
|
||||
call kb_wait
|
||||
movb $0xed,%al /* set leds command */
|
||||
outb %al,$0x60
|
||||
call kb_wait
|
||||
movb leds,%al
|
||||
outb %al,$0x60
|
||||
ret
|
||||
uncaps: andb $0x7f,mode
|
||||
ret
|
||||
scroll:
|
||||
xorb $1,leds
|
||||
jmp set_leds
|
||||
num: xorb $2,leds
|
||||
jmp set_leds
|
||||
|
||||
/*
|
||||
* curosr-key/numeric keypad cursor keys are handled here.
|
||||
* checking for numeric keypad etc.
|
||||
*/
|
||||
cursor:
|
||||
subb $0x47,%al
|
||||
jb 1f
|
||||
cmpb $12,%al
|
||||
ja 1f
|
||||
jne cur2 /* check for ctrl-alt-del */
|
||||
testb $0x0c,mode
|
||||
je cur2
|
||||
testb $0x30,mode
|
||||
jne reboot
|
||||
cur2: cmpb $0x01,e0 /* e0 forces cursor movement */
|
||||
je cur
|
||||
testb $0x02,leds /* not num-lock forces cursor */
|
||||
je cur
|
||||
testb $0x03,mode /* shift forces cursor */
|
||||
jne cur
|
||||
xorl %ebx,%ebx
|
||||
movb num_table(%eax),%al
|
||||
jmp put_queue
|
||||
1: ret
|
||||
|
||||
cur: movb cur_table(%eax),%al
|
||||
cmpb $'9,%al
|
||||
ja ok_cur
|
||||
movb $'~,%ah
|
||||
ok_cur: shll $16,%eax
|
||||
movw $0x5b1b,%ax
|
||||
xorl %ebx,%ebx
|
||||
jmp put_queue
|
||||
|
||||
#if defined(KBD_FR)
|
||||
num_table:
|
||||
.ascii "789 456 1230."
|
||||
#else
|
||||
num_table:
|
||||
.ascii "789 456 1230,"
|
||||
#endif
|
||||
cur_table:
|
||||
.ascii "HA5 DGC YB623"
|
||||
|
||||
/*
|
||||
* this routine handles function keys
|
||||
*/
|
||||
func:
|
||||
pushl %eax
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
call show_stat
|
||||
popl %edx
|
||||
popl %ecx
|
||||
popl %eax
|
||||
subb $0x3B,%al
|
||||
jb end_func
|
||||
cmpb $9,%al
|
||||
jbe ok_func
|
||||
subb $18,%al
|
||||
cmpb $10,%al
|
||||
jb end_func
|
||||
cmpb $11,%al
|
||||
ja end_func
|
||||
ok_func:
|
||||
cmpl $4,%ecx /* check that there is enough room */
|
||||
jl end_func
|
||||
movl func_table(,%eax,4),%eax
|
||||
xorl %ebx,%ebx
|
||||
jmp put_queue
|
||||
end_func:
|
||||
ret
|
||||
|
||||
/*
|
||||
* function keys send F1:'esc [ [ A' F2:'esc [ [ B' etc.
|
||||
*/
|
||||
func_table:
|
||||
.long 0x415b5b1b,0x425b5b1b,0x435b5b1b,0x445b5b1b
|
||||
.long 0x455b5b1b,0x465b5b1b,0x475b5b1b,0x485b5b1b
|
||||
.long 0x495b5b1b,0x4a5b5b1b,0x4b5b5b1b,0x4c5b5b1b
|
||||
|
||||
#if defined(KBD_FINNISH)
|
||||
key_map:
|
||||
.byte 0,27
|
||||
.ascii "1234567890+'"
|
||||
.byte 127,9
|
||||
.ascii "qwertyuiop}"
|
||||
.byte 0,13,0
|
||||
.ascii "asdfghjkl|{"
|
||||
.byte 0,0
|
||||
.ascii "'zxcvbnm,.-"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '<
|
||||
.fill 10,1,0
|
||||
|
||||
shift_map:
|
||||
.byte 0,27
|
||||
.ascii "!\"#$%&/()=?`"
|
||||
.byte 127,9
|
||||
.ascii "QWERTYUIOP]^"
|
||||
.byte 13,0
|
||||
.ascii "ASDFGHJKL\\["
|
||||
.byte 0,0
|
||||
.ascii "*ZXCVBNM;:_"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '>
|
||||
.fill 10,1,0
|
||||
|
||||
alt_map:
|
||||
.byte 0,0
|
||||
.ascii "\0@\0$\0\0{[]}\\\0"
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte '~,13,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0,0,0 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte 0,0,0,0,0 /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '|
|
||||
.fill 10,1,0
|
||||
|
||||
#elif defined(KBD_US)
|
||||
|
||||
key_map:
|
||||
.byte 0,27
|
||||
.ascii "1234567890-="
|
||||
.byte 127,9
|
||||
.ascii "qwertyuiop[]"
|
||||
.byte 13,0
|
||||
.ascii "asdfghjkl;'"
|
||||
.byte '`,0
|
||||
.ascii "\\zxcvbnm,./"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '<
|
||||
.fill 10,1,0
|
||||
|
||||
|
||||
shift_map:
|
||||
.byte 0,27
|
||||
.ascii "!@#$%^&*()_+"
|
||||
.byte 127,9
|
||||
.ascii "QWERTYUIOP{}"
|
||||
.byte 13,0
|
||||
.ascii "ASDFGHJKL:\""
|
||||
.byte '~,0
|
||||
.ascii "|ZXCVBNM<>?"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '>
|
||||
.fill 10,1,0
|
||||
|
||||
alt_map:
|
||||
.byte 0,0
|
||||
.ascii "\0@\0$\0\0{[]}\\\0"
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte '~,13,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0,0,0 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte 0,0,0,0,0 /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '|
|
||||
.fill 10,1,0
|
||||
|
||||
#elif defined(KBD_GR)
|
||||
|
||||
key_map:
|
||||
.byte 0,27
|
||||
.ascii "1234567890\\'"
|
||||
.byte 127,9
|
||||
.ascii "qwertzuiop@+"
|
||||
.byte 13,0
|
||||
.ascii "asdfghjkl[]^"
|
||||
.byte 0,'#
|
||||
.ascii "yxcvbnm,.-"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '<
|
||||
.fill 10,1,0
|
||||
|
||||
|
||||
shift_map:
|
||||
.byte 0,27
|
||||
.ascii "!\"#$%&/()=?`"
|
||||
.byte 127,9
|
||||
.ascii "QWERTZUIOP\\*"
|
||||
.byte 13,0
|
||||
.ascii "ASDFGHJKL{}~"
|
||||
.byte 0,''
|
||||
.ascii "YXCVBNM;:_"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '>
|
||||
.fill 10,1,0
|
||||
|
||||
alt_map:
|
||||
.byte 0,0
|
||||
.ascii "\0@\0$\0\0{[]}\\\0"
|
||||
.byte 0,0
|
||||
.byte '@,0,0,0,0,0,0,0,0,0,0
|
||||
.byte '~,13,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0,0,0 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte 0,0,0,0,0 /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '|
|
||||
.fill 10,1,0
|
||||
|
||||
|
||||
#elif defined(KBD_FR)
|
||||
|
||||
key_map:
|
||||
.byte 0,27
|
||||
.ascii "&{\"'(-}_/@)="
|
||||
.byte 127,9
|
||||
.ascii "azertyuiop^$"
|
||||
.byte 13,0
|
||||
.ascii "qsdfghjklm|"
|
||||
.byte '`,0,42 /* coin sup gauche, don't know, [*|mu] */
|
||||
.ascii "wxcvbn,;:!"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '<
|
||||
.fill 10,1,0
|
||||
|
||||
shift_map:
|
||||
.byte 0,27
|
||||
.ascii "1234567890]+"
|
||||
.byte 127,9
|
||||
.ascii "AZERTYUIOP<>"
|
||||
.byte 13,0
|
||||
.ascii "QSDFGHJKLM%"
|
||||
.byte '~,0,'#
|
||||
.ascii "WXCVBN?./\\"
|
||||
.byte 0,'*,0,32 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte '-,0,0,0,'+ /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '>
|
||||
.fill 10,1,0
|
||||
|
||||
alt_map:
|
||||
.byte 0,0
|
||||
.ascii "\0~#{[|`\\^@]}"
|
||||
.byte 0,0
|
||||
.byte '@,0,0,0,0,0,0,0,0,0,0
|
||||
.byte '~,13,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0
|
||||
.byte 0,0,0,0,0,0,0,0,0,0,0
|
||||
.byte 0,0,0,0 /* 36-39 */
|
||||
.fill 16,1,0 /* 3A-49 */
|
||||
.byte 0,0,0,0,0 /* 4A-4E */
|
||||
.byte 0,0,0,0,0,0,0 /* 4F-55 */
|
||||
.byte '|
|
||||
.fill 10,1,0
|
||||
|
||||
#else
|
||||
#error "KBD-type not defined"
|
||||
#endif
|
||||
/*
|
||||
* do_self handles "normal" keys, ie keys that don't change meaning
|
||||
* and which have just one character returns.
|
||||
*/
|
||||
do_self:
|
||||
lea alt_map,%ebx
|
||||
testb $0x20,mode /* alt-gr */
|
||||
jne 1f
|
||||
lea shift_map,%ebx
|
||||
testb $0x03,mode
|
||||
jne 1f
|
||||
lea key_map,%ebx
|
||||
1: movb (%ebx,%eax),%al
|
||||
orb %al,%al
|
||||
je none
|
||||
testb $0x4c,mode /* ctrl or caps */
|
||||
je 2f
|
||||
cmpb $'a,%al
|
||||
jb 2f
|
||||
cmpb $'},%al
|
||||
ja 2f
|
||||
subb $32,%al
|
||||
2: testb $0x0c,mode /* ctrl */
|
||||
je 3f
|
||||
cmpb $64,%al
|
||||
jb 3f
|
||||
cmpb $64+32,%al
|
||||
jae 3f
|
||||
subb $64,%al
|
||||
3: testb $0x10,mode /* left alt */
|
||||
je 4f
|
||||
orb $0x80,%al
|
||||
4: andl $0xff,%eax
|
||||
xorl %ebx,%ebx
|
||||
call put_queue
|
||||
none: ret
|
||||
|
||||
/*
|
||||
* minus has a routine of it's own, as a 'E0h' before
|
||||
* the scan code for minus means that the numeric keypad
|
||||
* slash was pushed.
|
||||
*/
|
||||
minus: cmpb $1,e0
|
||||
jne do_self
|
||||
movl $'/,%eax
|
||||
xorl %ebx,%ebx
|
||||
jmp put_queue
|
||||
|
||||
/*
|
||||
* This table decides which routine to call when a scan-code has been
|
||||
* gotten. Most routines just call do_self, or none, depending if
|
||||
* they are make or break.
|
||||
*/
|
||||
key_table:
|
||||
.long none,do_self,do_self,do_self /* 00-03 s0 esc 1 2 */
|
||||
.long do_self,do_self,do_self,do_self /* 04-07 3 4 5 6 */
|
||||
.long do_self,do_self,do_self,do_self /* 08-0B 7 8 9 0 */
|
||||
.long do_self,do_self,do_self,do_self /* 0C-0F + ' bs tab */
|
||||
.long do_self,do_self,do_self,do_self /* 10-13 q w e r */
|
||||
.long do_self,do_self,do_self,do_self /* 14-17 t y u i */
|
||||
.long do_self,do_self,do_self,do_self /* 18-1B o p } ^ */
|
||||
.long do_self,ctrl,do_self,do_self /* 1C-1F enter ctrl a s */
|
||||
.long do_self,do_self,do_self,do_self /* 20-23 d f g h */
|
||||
.long do_self,do_self,do_self,do_self /* 24-27 j k l | */
|
||||
.long do_self,do_self,lshift,do_self /* 28-2B { para lshift , */
|
||||
.long do_self,do_self,do_self,do_self /* 2C-2F z x c v */
|
||||
.long do_self,do_self,do_self,do_self /* 30-33 b n m , */
|
||||
.long do_self,minus,rshift,do_self /* 34-37 . - rshift * */
|
||||
.long alt,do_self,caps,func /* 38-3B alt sp caps f1 */
|
||||
.long func,func,func,func /* 3C-3F f2 f3 f4 f5 */
|
||||
.long func,func,func,func /* 40-43 f6 f7 f8 f9 */
|
||||
.long func,num,scroll,cursor /* 44-47 f10 num scr home */
|
||||
.long cursor,cursor,do_self,cursor /* 48-4B up pgup - left */
|
||||
.long cursor,cursor,do_self,cursor /* 4C-4F n5 right + end */
|
||||
.long cursor,cursor,cursor,cursor /* 50-53 dn pgdn ins del */
|
||||
.long none,none,do_self,func /* 54-57 sysreq ? < f11 */
|
||||
.long func,none,none,none /* 58-5B f12 ? ? ? */
|
||||
.long none,none,none,none /* 5C-5F ? ? ? ? */
|
||||
.long none,none,none,none /* 60-63 ? ? ? ? */
|
||||
.long none,none,none,none /* 64-67 ? ? ? ? */
|
||||
.long none,none,none,none /* 68-6B ? ? ? ? */
|
||||
.long none,none,none,none /* 6C-6F ? ? ? ? */
|
||||
.long none,none,none,none /* 70-73 ? ? ? ? */
|
||||
.long none,none,none,none /* 74-77 ? ? ? ? */
|
||||
.long none,none,none,none /* 78-7B ? ? ? ? */
|
||||
.long none,none,none,none /* 7C-7F ? ? ? ? */
|
||||
.long none,none,none,none /* 80-83 ? br br br */
|
||||
.long none,none,none,none /* 84-87 br br br br */
|
||||
.long none,none,none,none /* 88-8B br br br br */
|
||||
.long none,none,none,none /* 8C-8F br br br br */
|
||||
.long none,none,none,none /* 90-93 br br br br */
|
||||
.long none,none,none,none /* 94-97 br br br br */
|
||||
.long none,none,none,none /* 98-9B br br br br */
|
||||
.long none,unctrl,none,none /* 9C-9F br unctrl br br */
|
||||
.long none,none,none,none /* A0-A3 br br br br */
|
||||
.long none,none,none,none /* A4-A7 br br br br */
|
||||
.long none,none,unlshift,none /* A8-AB br br unlshift br */
|
||||
.long none,none,none,none /* AC-AF br br br br */
|
||||
.long none,none,none,none /* B0-B3 br br br br */
|
||||
.long none,none,unrshift,none /* B4-B7 br br unrshift br */
|
||||
.long unalt,none,uncaps,none /* B8-BB unalt br uncaps br */
|
||||
.long none,none,none,none /* BC-BF br br br br */
|
||||
.long none,none,none,none /* C0-C3 br br br br */
|
||||
.long none,none,none,none /* C4-C7 br br br br */
|
||||
.long none,none,none,none /* C8-CB br br br br */
|
||||
.long none,none,none,none /* CC-CF br br br br */
|
||||
.long none,none,none,none /* D0-D3 br br br br */
|
||||
.long none,none,none,none /* D4-D7 br br br br */
|
||||
.long none,none,none,none /* D8-DB br ? ? ? */
|
||||
.long none,none,none,none /* DC-DF ? ? ? ? */
|
||||
.long none,none,none,none /* E0-E3 e0 e1 ? ? */
|
||||
.long none,none,none,none /* E4-E7 ? ? ? ? */
|
||||
.long none,none,none,none /* E8-EB ? ? ? ? */
|
||||
.long none,none,none,none /* EC-EF ? ? ? ? */
|
||||
.long none,none,none,none /* F0-F3 ? ? ? ? */
|
||||
.long none,none,none,none /* F4-F7 ? ? ? ? */
|
||||
.long none,none,none,none /* F8-FB ? ? ? ? */
|
||||
.long none,none,none,none /* FC-FF ? ? ? ? */
|
||||
|
||||
/*
|
||||
* kb_wait waits for the keyboard controller buffer to empty.
|
||||
* there is no timeout - if the buffer doesn't empty, we hang.
|
||||
*/
|
||||
kb_wait:
|
||||
pushl %eax
|
||||
1: inb $0x64,%al
|
||||
testb $0x02,%al
|
||||
jne 1b
|
||||
popl %eax
|
||||
ret
|
||||
/*
|
||||
* This routine reboots the machine by asking the keyboard
|
||||
* controller to pulse the reset-line low.
|
||||
*/
|
||||
reboot:
|
||||
call kb_wait
|
||||
movw $0x1234,0x472 /* don't do memory check */
|
||||
movb $0xfc,%al /* pulse reset and A20 low */
|
||||
outb %al,$0x64
|
||||
die: jmp die
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue