xref: /titanic_50/usr/src/psm/stand/bootblks/ufs/common/ufs.fth (revision c713350eb0c205161e2a4ab06cd996300721ac78)

\
\ CDDL HEADER START
\
\ The contents of this file are subject to the terms of the
\ Common Development and Distribution License (the "License").
\ You may not use this file except in compliance with the License.
\
\ You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
\ or http://www.opensolaris.org/os/licensing.
\ See the License for the specific language governing permissions
\ and limitations under the License.
\
\ When distributing Covered Code, include this CDDL HEADER in each
\ file and include the License file at usr/src/OPENSOLARIS.LICENSE.
\ If applicable, add the following below this CDDL HEADER, with the
\ fields enclosed by brackets "[]" replaced with your own identifying
\ information: Portions Copyright [yyyy] [name of copyright owner]
\
\ CDDL HEADER END
\
\
\ Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
\ Use is subject to license terms.
\


purpose: UFS file system support package
copyright: Copyright 2009 Sun Microsystems, Inc. All Rights Reserved

headers
" /packages" get-package  push-package

new-device
   fs-pkg$  device-name  diag-cr?

   \
   \	UFS low-level block routines
   \

   h# 2000  constant  /max-bsize
   d# 512   constant  /disk-block

   0 instance value dev-ih
   0 instance value temp-block

   : blk>byte ( block# -- byte# )  /disk-block *  ;

   : read-disk-blocks  ( adr len dev-block# -- )
      blk>byte dev-ih  read-disk
   ;


   \
   \	UFS superblock routines
   \

   d# 512 constant /super-block
   d#  16 constant super-block#
   0 instance value super-block

   : +sb  ( index -- value )  super-block  swap la+ l@  ;
   : iblkno    ( -- n )  d# 04 +sb  ;
   : cgoffset  ( -- n )  d# 06 +sb  ;
   : cgmask    ( -- n )  d# 07 +sb  ;
   : bsize     ( -- n )  d# 12 +sb  ;
   : fragshift ( -- n )  d# 24 +sb  ;
   : fsbtodbc  ( -- n )  d# 25 +sb  ;
   : inopb     ( -- n )  d# 30 +sb  ;
   : ipg       ( -- n )  d# 46 +sb  ;
   : fpg       ( -- n )  d# 47 +sb  ;

   : /frag  ( -- fragsize )  bsize fragshift rshift ;

   : get-super-block  ( -- )
      super-block /super-block super-block#  read-disk-blocks
   ;

   : cgstart   ( cg -- block# )
      dup cgmask invert and  cgoffset *   swap fpg *  +
   ;
   : cgimin       ( cg -- block# )  cgstart  iblkno +  ;
   : blkstofrags  ( #blocks -- #frags )  fragshift lshift  ;
   : lblkno       ( byte-off -- lblk# )  bsize /  ;
   : blkoff       ( byte-off -- blk-off )  bsize mod  ;
   : fsbtodb      ( fs-blk# -- dev-blk# )  fsbtodbc lshift  ;

   : read-fs-blocks  ( adr len fs-blk# -- )  fsbtodb read-disk-blocks  ;


   \
   \	UFS inode routines
   \

   h# 80 constant /inode
   0 instance value inode
   0 instance value iptr

   : itoo  ( i# -- offset )  inopb mod  ;
   : itog  ( i# -- group )  ipg /  ;
   : itod  ( i# -- block# )
      dup itog cgimin  swap ipg mod  inopb /  blkstofrags  +
   ;

   : +i  ( n -- adr )  iptr +  ;

   : ftype ( -- n )  0 +i  w@  h# f000 and  ;
   : dir?      ( -- flag )  ftype h# 4000 =  ;
   : symlink?  ( -- flag )  ftype h# a000 =  ;
   : regular?  ( -- flag )  ftype h# 8000 =  ;

   : file-size  ( -- n )        8 +i x@  ;
   : direct0    ( -- adr )  d# 40 +i  ;
   : indirect0  ( -- adr )  d# 88 +i  ;
   : indirect1  ( -- adr )  d# 92 +i  ;
   : indirect2  ( -- adr )  d# 96 +i  ;
   : comp?      ( -- flag ) d# 100 +i l@  4 and  0<> ;

   0 instance value current-file
   : iget  ( i# -- )
      dup temp-block bsize  rot  itod        ( i# adr len blk# )
      read-fs-blocks
      dup itoo  /inode *  temp-block +  inode /inode  move
      inode to iptr
      to current-file                        (  )
   ;

   : l@++  ( ptr -- value )  dup @ l@  /l rot +!  ;

   d# 12 constant #direct
   : #blk-addr/blk  bsize /l /  ;
   : #sgl-addr      #blk-addr/blk  ;
   : #dbl-addr      #sgl-addr #blk-addr/blk *  ;
\  : #tri-addr      #dbl-addr #blk-addr/blk *  ;

   : >1-idx ( blk# -- idx )  #blk-addr/blk mod  ;
   : >2-idx ( blk# -- idx )  #sgl-addr /  >1-idx  ;
\  : >3-idx ( blk# -- idx )  #dbl-addr /  >1-idx  ;

   \
   \ indirect block cache
   \ we assume reads will mostly be sequential, and only
   \ cache the current indirect block tree
   \
   : get-indir  ( fs-blk# var adr -- adr )
      -rot  dup >r   @ over  =  if             ( adr fs-blk#  r: var )
         r> 2drop  exit                        ( adr )
      then                                     ( adr fs-blk#  r: var )
      2dup  bsize swap  read-fs-blocks         ( adr fs-blk#  r: var )
      r> !                                     ( adr )
   ;

   0 instance value indir0-adr
   instance variable cur-indir0
   : get-indir0  ( fs-blk# -- adr )
      cur-indir0 indir0-adr  get-indir
   ;

   0 instance value indir1-adr
   instance variable cur-indir1
   : get-indir1  ( fs-blk# -- adr )
      cur-indir1 indir1-adr  get-indir
   ;

   \
   \ blkptr and blklim point to an array of blk#s,
   \ whether in the inode direct block array or in
   \ an indirect block
   \
   instance variable blkptr
   instance variable blklim

   : (bmap)  ( lblk# -- )
      dup  #direct <  if                           ( lblk# )
         direct0 swap la+  blkptr  !               (  )
         direct0 #direct la+  blklim  !
         exit
      then                                         ( lblk# )

      #direct -                                    ( lblk#' )
      dup  #sgl-addr <  if
         indirect0 l@  get-indir0                  ( lblk# adr )
         tuck  swap >1-idx la+  blkptr  !          ( adr )
         #blk-addr/blk la+  blklim  !
         exit
      then                                         ( lblk# )

      #sgl-addr -                                  ( lblk#' )
      dup  #dbl-addr <  if
         indirect1 l@  get-indir0                  ( lblk# adr )
         over >2-idx la+ l@  get-indir1            ( lblk# adr' )
         tuck  swap >1-idx la+  blkptr  !          ( adr )
         #blk-addr/blk la+  blklim  !              (  )
         exit
      then                                         ( lblk# )

\     #dbl-addr -                                  ( lblk#' )
\     dup  #tri-addr <  if
\        indirect2 l@  get-indir0                  ( lblk# adr )
\        over >3-idx la+ l@  get-indir1            ( lblk# adr' )
\        over >2-idx la+ l@  get-indir2            ( lblk# adr' )
\        tuck  swap >1-idx la+  blkptr  !          ( adr )
\        #blk-addr/blk la+  blklim  !              (  )
\        exit
\     then                                         ( lblk# )
      ." file too large" cr  drop true             ( failed )
   ;

   0 instance value cur-blk
   : bmap  ( lblk# -- fs-blk# )
      dup cur-blk <>  blkptr @  blklim @ =  or  if       ( lblk# )
         dup (bmap)                                      ( lblk# )
      then                                               ( lblk# )
      1+ to cur-blk                                      (  )
      blkptr l@++                                        ( fs-blk# )
   ;

   : read-one-block ( adr block# -- )
      bmap  ?dup  if
         bsize swap  read-fs-blocks
      else
         bsize  erase
      then
   ;

   : read-partial-block ( adr len off block# -- )
      bmap  ?dup  if
         fsbtodb  blk>byte +                        ( adr len byte# )
         dev-ih  read-disk
      else
         drop  erase
      then
   ;

   \
   \	UFS directory routines
   \

   instance variable dir-blk
   instance variable totoff
   instance variable dirptr
   0 instance value dir-buf

   : get-dirblk  ( -- )
      dir-buf bsize  dir-blk @  bmap    ( adr len fs-blk# )
      read-fs-blocks                    ( )
      1 dir-blk +!
   ;

   2 constant rootino

   : +d  ( n -- adr ) dirptr @  +  ;

   : dir-ino    ( -- adr ) 0 +d  l@  ;
   : reclen     ( -- adr ) 4 +d  w@  ;
   : namelen    ( -- adr ) 6 +d  w@  ;
   : dir-name   ( -- adr ) 8 +d  ;
   : dir-name$  ( -- file$ ) dir-name namelen  ;


   \
   \	UFS high-level routines
   \
   \       After this point, the code should be independent of the disk format!

   0 instance value search-dir
   : init-dent
      0 totoff !  0 dir-blk !
      current-file to search-dir
   ;

   : get-dent ( -- end-of-dir? )
      begin
         totoff @  file-size >=  if
            true  exit
         then
         totoff @  blkoff  0=  if
            get-dirblk
            dir-buf dirptr !
         else
            reclen dirptr +!
         then
         reclen totoff +!
         dir-ino  0<>
      until  false
   ;

   : dirlook  ( file$ -- not-found? )
      init-dent
      begin  get-dent 0=  while      ( file$ )
         2dup  dir-name$  $=  if     ( file$ )
            dir-ino iget             ( file$ )
            2drop  false exit        ( found )
         then                        ( file$ )
      repeat  2drop true             ( not-found )
   ;

   h# 200 constant /fpath-buf
   /fpath-buf instance buffer: fpath-buf
   : clr-fpath-buf  ( -- )  fpath-buf /fpath-buf  erase  ;
   : fpath-buf$  ( -- path$ )  fpath-buf cscount  ;

   : follow-symlink  ( tail$ -- tail$' )
      clr-fpath-buf                                         ( tail$ )
      fpath-buf file-size  0 0  read-partial-block          ( tail$ )
      ?dup  if                                              ( tail$ )
	 " /" fpath-buf$  $append                           ( tail$ )
	 fpath-buf$  $append                                (  )
      else  drop  then                                      (  )
      fpath-buf$                                            ( path$ )
      over c@  ascii /  =  if                               ( path$ )
	 str++  rootino                                     ( path$' i# )
      else                                                  ( path$ )
	 search-dir                                         ( path$ i# )
      then                                                  ( path$ i# )
      iget                                                  ( path$ )
   ;

   : lookup  ( path$ -- not-found? )
      over c@  ascii /  =  if
         str++  rootino                           ( path$' i# )
      else
         current-file                             ( path$ i# )
      then                                        ( path$ i# )
      iget                                        ( path$ )
      begin                                       ( path$ )
         ascii / left-parse-string                ( path$ file$ )
      dup  while
         dir? 0=  if  2drop true  exit  then
         dirlook  if  2drop true  exit  then      ( path$ )
         symlink?  if
            follow-symlink                        ( path$' )
         then                                     ( path$ )
      repeat                                      ( path$ file$ )
      2drop 2drop  false                          ( succeeded )
   ;

   : i#>name ( i# -- name$ )
      init-dent                      ( i# )
      begin  get-dent 0=  while      ( i# )
         dup dir-ino  =  if          ( i# )
            drop dir-name$  exit     ( name$ )
         then                        ( i# )
      repeat  drop " ???"            ( name$ )
   ;


   \
   \	UFS installation routines
   \

   /max-bsize  4 *
   /super-block    +
   /inode          +
   constant alloc-size

   \ **** Allocate memory for necessary data structures
   : allocate-buffers  ( -- )
      alloc-size mem-alloc  dup 0=  if
         ." no memory"  abort
      then                                ( adr )
      dup to temp-block   /max-bsize   +  ( adr )
      dup to dir-buf      /max-bsize   +  ( adr )
      dup to indir0-adr   /max-bsize   +  ( adr )
      dup to indir1-adr   /max-bsize   +  ( adr )
      dup to super-block  /super-block +  ( adr )
          to inode                        (  )
   ;

   : release-buffers  ( -- )
      temp-block  alloc-size  mem-free
   ;

   \ UFS file interface

   struct
      /x     field >busy
      /x     field >offset
      /inode field >inode
   constant /file-record

   d# 10                  constant #opens
   #opens /file-record *  constant /file-records

   /file-records  instance buffer: file-records

   -1 instance value current-fd
   : fd>record  ( fd -- record )  /file-record *  file-records +  ;


   : file-offset@  ( -- off )
      current-fd fd>record >offset  x@
   ;

   : file-offset!  ( off -- )
      current-fd fd>record >offset  x!
   ;

   : get-slot  ( -- fd false | true )
      #opens 0  do
         i fd>record >busy x@  0=  if
            i false  unloop exit
         then
      loop  true
   ;

   : free-slot  ( fd -- )
      0 swap  fd>record >busy  x!
   ;

   : init-fd  ( fd -- )
      fd>record                ( rec )
      dup  >busy  1 swap  x!
      dup  >inode  inode swap  /inode  move
      >offset  0 swap  x!
   ;

   : set-fd  ( fd -- error? )
      dup fd>record  dup >busy x@  0=  if   ( fd rec )
         2drop true  exit                   ( failed )
      then
      >inode to iptr                        ( fd )
      to current-fd  false                  ( succeeded )
   ;


   \ get current lblk# and offset within it
   : file-blk+off ( -- off block# )
      file-offset@ dup  blkoff  swap lblkno
   ;

   \ advance file io stack by n
   : fio+  ( # adr len n -- #+n adr+n len-n )
      dup file-offset@ +  file-offset!
      dup >r  -  -rot   ( len' # adr  r: n )
      r@  +  -rot       ( adr' len' #  r: n )
      r>  +  -rot       ( #' adr' len' )
   ;

   : (cwd)  ( i# -- )  tokenizer[ reveal ]tokenizer
      dup rootino  <>  if
         \ open parent, find current name
         " .." lookup  drop
         i#>name                ( name$ )
         \ recurse to print path components above
         current-file (cwd)     ( name$ )
         \ and print this component
         type                   (  )
      else  drop  then          (  )
      \ slash is both root name and separator
      ." /"
   ;

   external

   : open ( -- okay? )
      my-args dev-open  dup 0=  if       ( 0 )
         exit                            ( failed )
      then  to dev-ih

      allocate-buffers
      get-super-block
      file-records /file-records  erase
      true                               ( succeeded )
   ;

   : close  ( -- )
      dev-ih dev-close
      0 to dev-ih
      release-buffers
   ;

   : open-file  ( path$ -- fd true | false )
      get-slot  if
         2drop false  exit         ( failed )
      then  -rot                   ( fd path$ )

      lookup  if                   ( fd )
         drop false  exit          ( failed )
      then

      dup init-fd  true            ( fd succeeded )
   ;

   : close-file  ( fd -- )
      free-slot   (  )
   ;

   : size-file  ( fd -- size )
      set-fd  if  0  else  file-size  then
   ;

   : seek-file  ( off fd -- off true | false )
      set-fd  if                ( off )
         drop false  exit       ( failed )
      then                      ( off )

      dup file-size >  if       ( off )
         drop false  exit       ( failed )
      then                      ( off )
      dup  file-offset!  true   ( off succeeded )
   ;

   : read-file  ( adr len fd -- #read )
      set-fd  if                   ( adr len )
         2drop 0  exit             ( 0 )
      then                         ( adr len )

      regular? 0=  if  2drop 0  exit  then

      \ adjust len if reading past eof
      dup  file-offset@ +  file-size  >  if
         dup  file-offset@ +  file-size -  -
      then
      dup 0=  if  nip exit  then

      0 -rot                              ( #read adr len )

      \ initial partial block
      file-offset@ blkoff  ?dup  if       ( #read adr len off )
         bsize swap -  over  min          ( #read adr len len' )
         3dup nip  file-blk+off           ( #read adr len len' adr len' off lblk# )
         read-partial-block               ( #read adr len len )
         fio+                             ( #read' adr' len' )
      then                                ( #read adr len )

      dup lblkno  0  ?do                  ( #read adr len )
         over  file-blk+off nip           ( #read adr len adr lblk# )
         read-one-block                   ( #read adr len )
         bsize fio+                       ( #read' adr' len' )
      loop                                ( #read adr len )

      \ final partial block
      dup  if                             ( #read adr len )
         2dup  file-blk+off               ( #read adr len adr len off lblk# )
         read-partial-block               ( #read adr len )
         dup fio+                         ( #read' adr' 0 )
      then  2drop                         ( #read )
   ;

   : cinfo-file  ( fd -- bsize fsize comp? )
      set-fd  if  0 0 0  else  bsize file-size comp?  then
   ;

   \ read ramdisk fcode at rd-offset
   : get-rd   ( adr len -- )
      rd-offset dev-ih  read-disk
   ;

   \ no additional props needed for ufs
   : bootprop  ( -- )  false  ;

   \ debug words
   headers

   : chdir  ( dir$ -- )
      current-file -rot            ( i# dir$ )
      lookup  if                   ( i# )
         to current-file           (  )
         ." no such dir" cr  exit
      then                         ( i# )
      dir? 0=  if                  ( i# )
         to current-file           (  )
         ." not a dir" cr  exit
      then  drop                   (  )
   ;

   : dir  ( -- )
      current-file iget
      init-dent
      begin  get-dent 0=  while
         dir-name$ type  cr
      repeat
   ;

   : cwd  ( -- )
      current-file        ( i# )
      dup (cwd)  cr       ( i# )
      iget                (  )
   ;

finish-device
pop-package