| # |
| # linux_logo in i386 assembly language |
| # based on the code from ll_asm-0.36 |
| # |
| # By Vince Weaver <vince _at_ deater.net> |
| # |
| # Modified to remove non-deterministic system calls |
| # And to avoid reading from /proc |
| # |
| |
| .include "logo.include" |
| |
| # offsets into the results returned by the uname syscall |
| .equ U_SYSNAME,0 |
| .equ U_NODENAME,65 |
| .equ U_RELEASE,65*2 |
| .equ U_VERSION,(65*3) |
| .equ U_MACHINE,(65*4) |
| .equ U_DOMAINNAME,65*5 |
| |
| # offset into the results returned by the sysinfo syscall |
| .equ S_TOTALRAM,16 |
| |
| # Sycscalls |
| .equ SYSCALL_EXIT, 1 |
| .equ SYSCALL_WRITE, 4 |
| |
| # |
| .equ STDIN,0 |
| .equ STDOUT,1 |
| .equ STDERR,2 |
| |
| .globl _start |
| _start: |
| #========================= |
| # PRINT LOGO |
| #========================= |
| |
| # LZSS decompression algorithm implementation |
| # by Stephan Walter 2002, based on LZSS.C by Haruhiko Okumura 1989 |
| # optimized some more by Vince Weaver |
| |
| # we used to fill the buffer with FREQUENT_CHAR |
| # but, that only gains us one byte of space in the lzss image. |
| # the lzss algorithm does automatic RLE... pretty clever |
| # so we compress with NUL as FREQUENT_CHAR and it is pre-done for us |
| |
| mov $(N-F), %bp # R |
| |
| mov $logo, %esi # %esi points to logo (for lodsb) |
| |
| mov $out_buffer, %edi # point to out_buffer |
| push %edi # save this value for later |
| |
| decompression_loop: |
| lodsb # load in a byte |
| |
| mov $0xff, %bh # re-load top as a hackish 8-bit counter |
| mov %al, %bl # move in the flags |
| |
| test_flags: |
| cmp $logo_end, %esi # have we reached the end? |
| je done_logo # if so, exit |
| |
| shr $1, %ebx # shift bottom bit into carry flag |
| jc discrete_char # if set, we jump to discrete char |
| |
| offset_length: |
| lodsw # get match_length and match_position |
| mov %eax,%edx # copy to edx |
| # no need to mask dx, as we do it |
| # by default in output_loop |
| |
| shr $(P_BITS),%eax |
| add $(THRESHOLD+1),%al |
| mov %al,%cl # cl = (ax >> P_BITS) + THRESHOLD + 1 |
| # (=match_length) |
| |
| output_loop: |
| and $POSITION_MASK,%dh # mask it |
| mov text_buf(%edx), %al # load byte from text_buf[] |
| inc %edx # advance pointer in text_buf |
| store_byte: |
| stosb # store it |
| |
| mov %al, text_buf(%ebp) # store also to text_buf[r] |
| inc %ebp # r++ |
| and $(N-1), %bp # mask r |
| |
| loop output_loop # repeat until k>j |
| |
| or %bh,%bh # if 0 we shifted through 8 and must |
| jnz test_flags # re-load flags |
| |
| jmp decompression_loop |
| |
| discrete_char: |
| lodsb # load a byte |
| inc %ecx # we set ecx to one so byte |
| # will be output once |
| # (how do we know ecx is zero?) |
| |
| jmp store_byte # and cleverly store it |
| |
| |
| # end of LZSS code |
| |
| done_logo: |
| |
| pop %ebp # get out_buffer and keep in bp |
| mov %ebp,%ecx # move out_buffer to ecx |
| |
| call write_stdout # print the logo |
| |
| # |
| # Setup |
| # |
| setup: |
| mov $strcat,%edx # use edx as call pointer |
| |
| |
| #========================== |
| # PRINT VERSION |
| #========================== |
| |
| # push $SYSCALL_UNAME # uname syscall |
| # pop %eax # in 3 bytes |
| # mov $uname_info,%ebx # uname struct |
| # int $0x80 # do syscall |
| |
| mov %ebp,%edi # point %edi to out_buffer |
| |
| mov $(uname_info+U_SYSNAME),%esi # os-name from uname "Linux" |
| call *%edx # call strcat |
| |
| mov $ver_string,%esi # source is " Version " |
| call *%edx # call strcat |
| push %esi # save our .txt pointer |
| |
| mov $(uname_info+U_RELEASE),%esi # version from uname "2.4.1" |
| call *%edx # call strcat |
| |
| pop %esi # restore .txt pointer |
| # source is ", Compiled " |
| call *%edx # call strcat |
| push %esi # store for later |
| |
| mov $(uname_info+U_VERSION),%esi # compiled date |
| call *%edx # call strcat |
| |
| mov %ebp,%ecx # move out_buffer to ecx |
| |
| mov $0xa,%ax # store linefeed on end |
| stosw # and zero |
| |
| call *%edx # call strcat |
| |
| call center_and_print # center and print |
| |
| #=============================== |
| # Middle-Line |
| #=============================== |
| |
| #========= |
| # Load /proc/cpuinfo into buffer |
| #========= |
| |
| push %edx # save call pointer |
| |
| # push $SYSCALL_OPEN # load 5 [ open() ] |
| # pop %eax # in 3 bytes |
| |
| # mov $cpuinfo,%ebx # '/proc/cpuinfo' |
| # xor %ecx,%ecx # 0 = O_RDONLY <bits/fcntl.h> |
| # cdq # clear edx in clever way |
| # int $0x80 # syscall. fd in eax. |
| # we should check that eax>=0 |
| |
| # mov %eax,%ebx # save our fd |
| |
| # push $SYSCALL_READ # load 3 = read() |
| # pop %eax # in 3 bytes |
| |
| mov $disk_buffer,%ecx |
| |
| # mov $16,%dh # 4096 is maximum size of proc file #) |
| # we load sneakily by knowing |
| # 16<<8 = 4096. be sure edx clear |
| |
| |
| # int $0x80 |
| |
| # push $SYSCALL_CLOSE # close (to be correct) |
| # pop %eax |
| # int $0x80 |
| |
| #============= |
| # Number of CPUs |
| #============= |
| number_of_cpus: |
| |
| xor %ebx,%ebx # chip count |
| |
| # $disk_buffer still in ecx |
| bogo_loop: |
| mov (%ecx), %eax # load 4 bytes into eax |
| inc %ecx # increment pointer |
| |
| cmp $0,%al # check for end of file |
| je done_bogo |
| |
| # Grrr, due to a bug in binutils 2.18.50.0.9 |
| # (which unfortunately shipped with Fedora 10) |
| # http://sourceware.org/bugzilla/show_bug.cgi?id=6878 |
| # We can't use the apostrophe character |
| |
| # cmp $('o'<<24+'g'<<16+'o'<<8+'b'),%eax |
| cmp $(0x6f<<24+0x67<<16+0x6f<<8+0x62),%eax |
| # "bogo" in little-endian |
| |
| jne bogo_loop # if not equal, keep going |
| |
| inc %ebx # otherwise, we have a bogo |
| inc %ebx # times two for future magic |
| jmp bogo_loop |
| |
| done_bogo: |
| lea one-6(%ebx,%ebx,2), %esi |
| # Load into esi |
| # [one]+(num_cpus*6) |
| # |
| # the above multiplies by three |
| # esi = (ebx+(ebx*2)) |
| # and we double-incremented ebx |
| # earlier |
| |
| mov %ebp,%edi # move output buffer to edi |
| |
| pop %edx # restore call pointer |
| call *%edx # copy it (call strcat) |
| |
| # mov $' ',%al # print a space |
| mov $0x20,%al # print a space |
| stosb |
| |
| push %ebx # store cpu count |
| push %edx # store strcat pointer |
| |
| #========= |
| # MHz |
| #========= |
| print_mhz: |
| # mov $('z'<<24+'H'<<16+'M'<<8+' '),%ebx |
| mov $(0x7a<<24+0x48<<16+0x4d<<8+0x20),%ebx |
| # find ' MHz' and grab up to . |
| # we are little endian |
| # mov $'.',%ah |
| mov $0x2e,%ah |
| |
| # below is same as "sub $(strcat-find_string),%edx |
| # gas won't let us force the one-byte constant |
| .byte 0x83,0xEA,strcat-find_string |
| |
| call *%edx # call find string |
| |
| mov %ebx,%eax # clever way to get MHz in, sadly |
| ror $8,%eax # not any smaller than a mov |
| stosl |
| |
| #========= |
| # Chip Name |
| #========= |
| chip_name: |
| |
| # because of ugly newer cpuinfos from intel I had to hack this |
| # now we grab the first two words in the name field and use that |
| # it works on all recent Intel and AMD chips. Older things |
| # might choke |
| |
| # mov $('e'<<24+'m'<<16+'a'<<8+'n'),%ebx |
| mov $(0x65<<24+0x6d<<16+0x61<<8+0x6e),%ebx |
| # find 'name\t: ' and grab up to \n |
| # we are little endian |
| # mov $' ',%ah |
| mov $0x20,%ah |
| call *%edx # print first word |
| stosb # store a space |
| call skip_spaces # print next word |
| |
| pop %edx |
| pop %ebx # restore chip count |
| pop %esi |
| |
| call *%edx # ' Processor' |
| cmpb $2,%bl |
| jne print_s |
| inc %esi # if singular, skip the s |
| print_s: |
| call *%edx # 's, ' |
| |
| push %esi # restore the values |
| push %edx |
| |
| #======== |
| # RAM |
| #======== |
| |
| # push $SYSCALL_SYSINFO # sysinfo() syscall |
| # pop %eax |
| # mov $sysinfo_buff,%ebx |
| # int $0x80 |
| |
| mov (sysinfo_buff+S_TOTALRAM),%eax # size in bytes of RAM |
| shr $20,%eax # divide by 1024*1024 to get M |
| adc $0, %eax # round |
| |
| |
| call num_to_ascii |
| |
| pop %edx # restore strcat pointer |
| |
| pop %esi # print 'M RAM, ' |
| call *%edx # call strcat |
| |
| push %esi |
| |
| |
| #======== |
| # Bogomips |
| #======== |
| |
| # mov $('s'<<24+'p'<<16+'i'<<8+'m'),%ebx |
| mov $(0x73<<24+0x70<<16+0x69<<8+0x6d),%ebx |
| # find 'mips\t: ' and grab up to \n |
| mov $0xa,%ah |
| call find_string |
| |
| pop %esi # bogo total follows RAM |
| |
| call *%edx # call strcat |
| |
| push %esi |
| |
| mov %ebp,%ecx # point ecx to out_buffer |
| |
| |
| call center_and_print # center and print |
| |
| #================================= |
| # Print Host Name |
| #================================= |
| |
| mov %ebp,%edi # point to output_buffer |
| |
| mov $(uname_info+U_NODENAME),%esi # host name from uname() |
| call *%edx # call strcat |
| |
| # ecx is unchanged |
| call center_and_print # center and print |
| |
| pop %ecx # (.txt) pointer to default_colors |
| |
| call write_stdout |
| |
| |
| #================================ |
| # Exit |
| #================================ |
| exit: |
| xor %ebx,%ebx |
| xor %eax,%eax |
| inc %eax # put exit syscall number (1) in eax |
| int $0x80 # and exit |
| |
| |
| #================================= |
| # FIND_STRING |
| #================================= |
| # ah is char to end at |
| # ebx is 4-char ascii string to look for |
| # edi points at output buffer |
| |
| find_string: |
| |
| mov $disk_buffer-1,%esi # look in cpuinfo buffer |
| find_loop: |
| inc %esi |
| cmpb $0, (%esi) # are we at EOF? |
| je done # if so, done |
| |
| cmp (%esi), %ebx # do the strings match? |
| jne find_loop # if not, loop |
| |
| # ! if we get this far, we matched |
| |
| find_colon: |
| lodsb # repeat till we find colon |
| cmp $0,%al # this is actually smaller code |
| je done # than an or ecx/repnz scasb |
| |
| # cmp $':',%al |
| cmp $0x3a,%al |
| jne find_colon |
| |
| |
| skip_spaces: |
| lodsb # skip spaces |
| cmp $0x20,%al # Loser new intel chips have lots?? |
| je skip_spaces |
| |
| store_loop: |
| cmp $0,%al |
| je done |
| cmp %ah,%al # is it end string? |
| je almost_done # if so, finish |
| # cmp $'\n',%al # also end if linefeed |
| cmp $0xa,%al # also end if linefeed |
| je almost_done |
| stosb # if not store and continue |
| lodsb # load value |
| jmp store_loop |
| |
| almost_done: |
| |
| movb $0, (%edi) # replace last value with NUL |
| done: |
| ret |
| |
| |
| #================================ |
| # strcat |
| #================================ |
| |
| strcat: |
| lodsb # load a byte from [ds:esi] |
| stosb # store a byte to [es:edi] |
| cmp $0,%al # is it zero? |
| jne strcat # if not loop |
| dec %edi # point to one less than null |
| ret # return |
| |
| #============================== |
| # center_and_print |
| #============================== |
| # string to center in ecx |
| |
| center_and_print: |
| push %edx |
| push %ecx # save the string pointer |
| inc %edi # move to a clear buffer |
| push %edi # save for later |
| |
| # mov $('['<<8+27),%ax # we want to output ^[[ |
| mov $(0x5b<<8+27),%ax # we want to output ^[[ |
| stosw |
| |
| cdq # clear dx |
| |
| str_loop2: # find end of string |
| inc %edx |
| cmpb $0,(%ecx,%edx) # repeat till we find zero |
| jne str_loop2 |
| |
| push $81 # one added to cheat, we don't |
| # count the trailing '\n' |
| pop %eax |
| |
| cmp %eax,%edx # see if we are >=80 |
| jl not_too_big # if so, don't center |
| push $80 |
| pop %edx |
| |
| not_too_big: |
| sub %edx,%eax # subtract size from 80 |
| |
| shr %eax # then divide by 2 |
| |
| call num_to_ascii # print number of spaces |
| # mov $'C',%al # tack a 'C' on the end |
| mov $0x43,%al # tack a 'C' on the end |
| # ah is zero from num_to_ascii |
| stosw # store C and a NULL |
| pop %ecx # pop the pointer to ^[[xC |
| |
| call write_stdout # write to the screen |
| |
| done_center: |
| pop %ecx # restore string pointer |
| # and trickily print the real string |
| |
| pop %edx |
| |
| #================================ |
| # WRITE_STDOUT |
| #================================ |
| # ecx has string |
| # eax,ebx,ecx,edx trashed |
| write_stdout: |
| push %edx |
| push $SYSCALL_WRITE # put 4 in eax (write syscall) |
| pop %eax # in 3 bytes of code |
| |
| cdq # clear edx |
| |
| xor %ebx,%ebx # put 1 in ebx (stdout) |
| inc %ebx # in 3 bytes of code |
| |
| # another way of doing this: lea 1(%edx), %ebx |
| |
| str_loop1: |
| inc %edx |
| cmpb $0,(%ecx,%edx) # repeat till zero |
| jne str_loop1 |
| |
| int $0x80 # run the syscall |
| pop %edx |
| ret |
| |
| ############################## |
| # num_to_ascii |
| ############################## |
| # ax = value to print |
| # edi points to where we want it |
| |
| num_to_ascii: |
| push $10 |
| pop %ebx |
| xor %ecx,%ecx # clear ecx |
| div_by_10: |
| cdq # clear edx |
| div %ebx # divide |
| push %edx # save for later |
| inc %ecx # add to length counter |
| or %eax,%eax # was Q zero? |
| jnz div_by_10 # if not divide again |
| |
| write_out: |
| pop %eax # restore in reverse order |
| add $0x30, %al # convert to ASCII |
| stosb # save digit |
| loop write_out # loop till done |
| ret |
| |
| #=========================================================================== |
| # section .data |
| #=========================================================================== |
| .data |
| |
| ver_string: .ascii " Version \0" |
| compiled_string: .ascii ", Compiled \0" |
| processor: .ascii " Processor\0" |
| s_comma: .ascii "s, \0" |
| ram_comma: .ascii "M RAM, \0" |
| bogo_total: .ascii " Bogomips Total\n\0" |
| |
| default_colors: .ascii "\033[0m\n\n\0" |
| |
| cpuinfo: .ascii "/proc/cpuinfo\0" |
| |
| |
| one: .ascii "One\0\0\0" |
| two: .ascii "Two\0\0\0" |
| three: .ascii "Three\0" |
| four: .ascii "Four\0" |
| |
| .include "logo.lzss_new" |
| |
| disk_buffer: |
| .ascii "processor : 0\n" |
| .ascii "vendor_id : AuthenticAMD\n" |
| .ascii "cpu family : 6\n" |
| .ascii "model : 6\n" |
| .ascii "model name : AMD Athlon(tm) XP 2000+\n" |
| .ascii "stepping : 2\n" |
| .ascii "cpu MHz : 1665.267\n" |
| .ascii "cache size : 256 KB\n" |
| .ascii "fdiv_bug : no\n" |
| .ascii "hlt_bug : no\n" |
| .ascii "f00f_bug : no\n" |
| .ascii "coma_bug : no\n" |
| .ascii "fpu : yes\n" |
| .ascii "fpu_exception : yes\n" |
| .ascii "cpuid level : 1\n" |
| .ascii "wp : yes\n" |
| .ascii "flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 mmx fxsr sse syscall mmxext 3dnowext 3dnow up\n" |
| .ascii "bogomips : 3330.53\n" |
| .ascii "clflush size : 32\n" |
| .ascii "power management: ts\n\0" |
| |
| uname_info: |
| .ascii "Linux\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| |
| .ascii "tobler\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| |
| .ascii "2.6.29\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| |
| .ascii "#1 SMP Mon May 4 09:51:54 EDT 2009\0\0" |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| .ascii "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" |
| |
| |
| sysinfo_buff: |
| .long 0,0,0,0,512*1024*1024,0,0,0,0 |
| .long 0,0,0,0,0,0,0,0,0 |
| |
| #============================================================================ |
| # section .bss |
| #============================================================================ |
| .bss |
| |
| .lcomm text_buf, (N+F-1) |
| .lcomm out_buffer,16384 |
| |
| |
| |
| |
| |
