Changeset 2796


Ignore:
Timestamp:
Jan 3, 2012, 1:54:24 AM (2 years ago)
Author:
wmb
Message:

EXT2 file system - converted many internal routines to use 64-bit block numbers as a step toward ext4 support.

Files:
10 edited

Legend:

Unmodified
Added
Removed
  • cpu/arm/kerncode.fth

    r2794 r2796  
    814814   mov       tos,tos,asr #0 
    815815c; 
     816code d>=  ( d1 d2 -- f ) 
     817   ldmia     sp!,{r0,r1,r2}     \ tos r0       r1 r2 
     818   subs      r2,r2,r0 
     819   sbcs      tos,r1,tos 
     820   mvn       tos,tos,asr #0 
     821c; 
    816822code d>  ( d1 d2 -- f ) 
    817823   ldmia     sp!,{r0,r1,r2}     \ tos r0       r1 r2 
     
    819825   sbcs      tos,tos,r1 
    820826   mov       tos,tos,asr #0 
     827c; 
     828code d<=  ( d1 d2 -- f ) 
     829   ldmia     sp!,{r0,r1,r2}     \ tos r0       r1 r2 
     830   subs      r0,r0,r2 
     831   sbcs      tos,tos,r1 
     832   mvn       tos,tos,asr #0 
    821833c; 
    822834code du<  ( d1 d2 -- f ) 
     
    863875   mvneq     tos,#0 
    864876   movne     tos,#0 
     877c; 
     878code d0<>  ( d -- f ) 
     879   pop       r0,sp 
     880   orrs      r0,r0,tos 
     881   mvnne     tos,#0 
     882   moveq     tos,#0 
    865883c; 
    866884code d0<  ( d -- f ) 
  • forth/kernel/double.fth

    r2794 r2796  
    66 
    77: d0=   ( d -- flag )  or  0=  ; 
     8: d0<>  ( d -- flag )  or  0<>  ; 
    89: d0<   ( d -- flag )  nip 0<  ; 
    910: d=    ( d1 d2 -- flag )  d- d0=  ; 
     
    1112: du<   ( ud1 ud2 -- flag )  rot  swap  2dup <>  if  2swap  then  2drop u<  ; 
    1213: d<    ( d1 d2 -- flag )  2 pick over = if drop nip u< else nip < nip then  ; 
     14: d>=   ( d1 d2 -- flag )  d< 0=  ; 
    1315: d>    ( d1 d2 -- flag )  2swap d<  ; 
     16: d<=   ( d1 d2 -- flag )  2swap d< 0=  ; 
    1417: dnegate  ( d -- -d )  0 0  2swap  d-  ; 
    1518: dabs     ( d -- +d )  2dup  d0<  if  dnegate  then  ; 
  • ofw/fs/ext2fs/bitmap.fth

    r1739 r2796  
    99 
    1010: gd-update   ( -- )   true to gd-modified?  ; 
    11 : block-bitmap  ( group# -- block# )   group-desc     le-l@  ; 
    12 : inode-bitmap  ( group# -- block# )   group-desc 4 + le-l@  ; 
    13 : inode-table   ( group# -- block# )   group-desc 8 + le-l@  ; 
    14 : free-blocks   ( group# -- n )    group-desc h# 0c + le-w@  ; 
     11: d.block-bitmap  ( group# -- d.block# ) 
     12   group-desc  dup le-l@       ( adr n ) 
     13   desc64?  if                 ( adr n ) 
     14      swap h# 20 + le-l@       ( d.block# ) 
     15   else                        ( adr n ) 
     16      nip u>d                  ( d.block# ) 
     17   then                        ( d.block# ) 
     18; 
     19: d.inode-bitmap  ( group# -- d.block# ) 
     20   group-desc  dup 4 + le-l@   ( adr n ) 
     21   desc64?  if                 ( adr n ) 
     22      swap h# 24 + le-l@       ( d.block# ) 
     23   else                        ( adr n ) 
     24      nip u>d                  ( d.block# ) 
     25   then                        ( d.block# ) 
     26; 
     27[ifdef] notdef 
     28: d.inode-table   ( group# -- d.block# ) 
     29   group-desc  dup 8 + le-l@   ( adr n ) 
     30   desc64?  if                 ( adr n ) 
     31      swap h# 28 + le-l@       ( d.block# ) 
     32   else                        ( adr n ) 
     33      nip u>d                  ( d.block# ) 
     34   then                        ( d.block# ) 
     35; 
     36[then] 
     37: free-blocks@  ( group# -- n ) 
     38   group-desc dup  h# 0c + le-w@       ( adr w ) 
     39   desc64?  if                         ( adr w ) 
     40      swap h# 2c + le-w@ wljoin        ( n ) 
     41   else                                ( adr w ) 
     42      nip                              ( n ) 
     43   then                                ( n ) 
     44; 
     45: free-blocks!  ( n group# -- ) 
     46   group-desc >r            ( n     r: adr ) 
     47   desc64?  if              ( n     r: adr ) 
     48      lwsplit               ( lo hi r: adr ) 
     49      r@ h# 2c + le-w!      ( lo    r: adr ) 
     50   then                     ( n     r: adr ) 
     51   r> h# 0c + le-w!         ( ) 
     52; 
     53 
    1554: free-blocks+!  ( n group# -- ) 
    16    group-desc h# 0c + 
    17    tuck le-w@ +  0 max  swap le-w!  gd-update 
    18 ; 
    19 : free-inodes   ( group# -- n )    group-desc h# 0e + le-w@  ; 
     55   tuck free-blocks@ +  0 max   ( group# n' ) 
     56   swap free-blocks!            ( ) 
     57   gd-update                    ( ) 
     58; 
     59: free-inodes@   ( group# -- n ) 
     60   group-desc  dup  h# 0e + le-w@   ( adr lo ) 
     61   desc64?  if                      ( adr lo ) 
     62      swap h# 2e + le-w@ wljoin     ( n ) 
     63   else                             ( adr lo ) 
     64      nip                           ( n ) 
     65   then                             ( n ) 
     66; 
     67: free-inodes!  ( n group# -- ) 
     68   group-desc >r            ( n     r: adr ) 
     69   desc64?  if              ( n     r: adr ) 
     70      lwsplit               ( lo hi r: adr ) 
     71      r@ h# 2e + le-w!      ( lo    r: adr ) 
     72   then                     ( n     r: adr ) 
     73   r> h# 0e + le-w!         ( ) 
     74; 
    2075: free-inodes+!  ( n inode# -- ) 
    21    group-desc h# 0e + 
    22    tuck le-w@ + swap le-w!  gd-update 
     76   tuck free-inodes@  +   ( group# n' ) 
     77   swap free-inodes!      ( ) 
     78   gd-update              ( ) 
    2379; 
    2480 
     
    65121 
    66122\ Find the first clear bit in a bitmap, set it if found 
    67 : first-free   ( len block# -- false | block#-in-group true ) 
    68    block swap                           ( map len ) 
     123: d.first-free   ( len d.block# -- false | block#-in-group true ) 
     124   d.block swap                         ( map len ) 
    69125 
    70126   2dup  h# ff bskip  dup  0=  if       ( map len 0 ) 
     
    89145; 
    90146 
    91 : clear-bit?  ( bit# block# -- cleared? ) 
    92    block  bitup                         ( mask adr' ) 
     147: d.clear-bit?  ( bit# d.block# -- cleared? ) 
     148   d.block  bitup                       ( mask adr' ) 
    93149   tuck c@                              ( adr mask byte ) 
    94150   2dup and  0=  if     \ Already free  ( adr mask byte ) 
    95       3drop  false  exit 
     151      3drop  false  exit                ( -- false ) 
    96152   then                                 ( adr mask byte ) 
    97153   swap invert and                      ( adr byte' ) 
    98154   swap c!                              ( ) 
    99155   update                               ( ) 
    100    true 
    101 ; 
    102  
    103 : free-block      ( block# -- ) 
    104    datablock0 - bpg /mod                ( bit# group# ) 
    105    tuck block-bitmap                    ( group# bit# block# ) 
    106    clear-bit?  if                       ( group# ) 
    107       1  swap  free-blocks+! 
     156   true                                 ( true ) 
     157; 
     158 
     159: d.free-block      ( d.block# -- ) 
     160   datablock0 u>d d- bpg um/mod         ( bit# group# ) 
     161   tuck d.block-bitmap                  ( group# bit# d.block# ) 
     162   d.clear-bit?  if                     ( group# ) 
     163      1  swap  free-blocks+!            ( ) 
    108164   else                                 ( group# ) 
    109       drop 
    110    then 
    111 ; 
    112  
    113 : alloc-block   ( -- block# ) 
     165      drop                              ( ) 
     166   then                                 ( ) 
     167; 
     168: n.free-block      ( block# -- )  u>d d.free-block  ; 
     169 
     170: d.alloc-block   ( -- d.block# ) 
    114171   #groups 0  ?do                       ( ) 
    115       i free-blocks  if                 ( ) 
     172      i free-blocks@  if                ( ) 
    116173         bpg 3 rshift  bsize min        ( len ) \ XXX stay in this block 
    117          i  block-bitmap                ( len block# ) 
    118          first-free  if                 ( block#-in-group ) 
     174         i  d.block-bitmap              ( len d.block# ) 
     175         d.first-free  if               ( block#-in-group ) 
    119176            -1 i free-blocks+!          ( block#-in-group ) 
    120             i bpg *  +  datablock0 +    ( block# ) 
    121             dup buffer bsize erase update       ( block# ) 
    122             unloop exit 
    123          else 
     177            u>d                         ( d.block#-in-group ) 
     178            i bpg um*  d+               ( d.block#-offset ) 
     179            datablock0 u>d d+           ( d.block# ) 
     180            2dup d.buffer bsize erase update    ( d.block# ) 
     181            unloop exit                 ( -- d.block# ) 
     182         else                           ( ) 
    124183            \ The allocation bitmap disagrees with the free block count, 
    125184            \ so fix the free block count to prevent thrashing. 
    126             i free-blocks  negate  i free-blocks+! 
     185            i free-blocks@  negate  i free-blocks+! 
    127186         then 
    128187      then 
     
    130189   true abort" no free blocks found" 
    131190; 
     191: u.alloc-block  ( -- n.block# ) 
     192   #groups 0  ?do                       ( ) 
     193      i 1+ bpg um*  datablock0 u>d d+   ( d.end-block# ) 
     194      h# 1.0000.0000. d>  abort" No free blocks found with 32-bit block number"  ( ) 
     195 
     196      i free-blocks@  if                ( ) 
     197         bpg 3 rshift  bsize min        ( len ) \ XXX stay in this block 
     198         i  d.block-bitmap              ( len d.block# ) 
     199         d.first-free  if               ( block#-in-group ) 
     200            -1 i free-blocks+!          ( block#-in-group ) 
     201            u>d                         ( d.block#-in-group ) 
     202            i bpg um*  d+               ( d.block#-offset ) 
     203            datablock0 u>d d+           ( d.block# ) 
     204            2dup d.buffer bsize erase update    ( d.block# ) 
     205            drop  unloop exit                   ( -- n.block# ) 
     206         else                           ( ) 
     207            \ The allocation bitmap disagrees with the free block count, 
     208            \ so fix the free block count to prevent thrashing. 
     209            i free-blocks@  negate  i free-blocks+! 
     210         then 
     211      then 
     212   loop 
     213   true abort" no free blocks found" 
     214; 
    132215 
    133216: free-inode      ( inode# -- ) 
    134217   1- ipg /mod                          ( bit# group# ) 
    135    tuck inode-bitmap                    ( group# bit# block# ) 
    136    clear-bit?  if                       ( group# ) 
     218   tuck d.inode-bitmap                  ( group# bit# d.block# ) 
     219   d.clear-bit?  if                     ( group# ) 
    137220      1  swap  free-inodes+! 
    138221   else                                 ( group# ) 
     
    144227   #groups 0 ?do 
    145228      ipg 3 rshift  bsize min           ( len )         \ XXX stay in this block 
    146       i  inode-bitmap                   ( len block# ) 
    147       first-free  if                    ( inode#-in-group ) 
     229      i  d.inode-bitmap                 ( len d.block# ) 
     230      d.first-free  if                  ( inode#-in-group ) 
    148231         -1 i free-inodes+!             ( inode#-in-group ) 
    149232         i ipg * +  1+                  ( inode# ) 
     
    156239 
    157240: update-sb   ( -- ) 
    158    0  #groups 0 ?do  i free-inodes +  loop  total-free-inodes! 
    159    0  #groups 0 ?do  i free-blocks +  loop  total-free-blocks! 
     241   0   #groups 0  ?do  i free-inodes@      +  loop    total-free-inodes! 
     242   0.  #groups 0  ?do  i free-blocks@ u>d d+  loop  d.total-free-blocks! 
    160243   put-super-block abort" failed to update superblock " 
    161    gds /gds gds-block# write-ublocks abort" failed to update group descriptors " 
     244   gds /gds d.gds-block# d.write-ublocks abort" failed to update group descriptors " 
    162245; 
    163246 
     
    170253      \ the calculated block number, do the backup. 
    171254      #groups 1  do 
    172          i bpg *  gds-fs-block# +       ( possible-gn ) 
    173          dup  i block-bitmap <  if      ( possible-gn ) 
    174             block                       ( gdn-adr ) 
    175             0 group-desc                ( gdn-adr gd0-adr ) 
    176             swap bsize move update      ( ) 
    177          else                           ( possible-gn ) 
    178             drop                        ( ) 
    179          then                           ( ) 
     255         i bpg * u>d  d.gds-fs-block# d+        ( d.possible-gn ) 
     256         2dup  i d.block-bitmap d<  if          ( d.possible-gn ) 
     257            d.block                             ( gdn-adr ) 
     258            0 group-desc                        ( gdn-adr gd0-adr ) 
     259            swap bsize move update              ( ) 
     260         else                                   ( d.possible-gn ) 
     261            2drop                               ( ) 
     262         then                                   ( ) 
    180263      loop 
    181264      false to gd-modified? 
     
    184267; 
    185268 
    186 : add-block   ( -- block# ) 
    187    #blks-held 2+ #blks-held! 
    188    alloc-block 
     269: d.add-block   ( -- d.block# ) 
     270   d.#blks-held 2. d+ d.#blks-held! 
     271   d.alloc-block 
     272; 
     273: u.add-block   ( -- block# ) 
     274   d.#blks-held 2. d+ d.#blks-held! 
     275   u.alloc-block 
    189276; 
    190277 
  • ofw/fs/ext2fs/blocks.fth

    r1753 r2796  
    1414struct  \ buffer 
    1515   /n field >dirty 
    16    /n field >blk# 
     16   2 /n * field >d.blk# 
    1717   \ /n field >device 
    1818   0 field >data 
     
    2424: dirty?    ( n -- dirty? )   >bufadr >dirty @  ; 
    2525: dirty!    ( dirty? n -- )   >bufadr >dirty !  ; 
    26 : blk#      ( n -- blk# )     >bufadr >blk# @  ; 
    27 : blk#!     ( blk# n -- )     >bufadr >blk# !  ; 
     26: d.blk#      ( n -- d.blk# )     >bufadr >d.blk# 2@  ; 
     27: d.blk#!     ( d.blk# n -- )     >bufadr >d.blk# 2!  ; 
    2828 
    2929create buf-table  #bufs allot 
    3030 
    31 : read-fs-block  ( adr fs-blk# -- error? ) 
    32    bsize  swap logbsize lshift  read-ublocks 
     31: d.read-fs-block  ( adr d.fs-blk# -- error? ) 
     32   bsize -rot  logbsize dlshift  d.read-ublocks 
    3333; 
    34 : write-fs-block  ( adr fs-blk# -- error? ) 
    35    bsize  swap logbsize lshift  write-ublocks 
     34: d.write-fs-block  ( adr d.fs-blk# -- error? ) 
     35   bsize -rot  logbsize dlshift  d.write-ublocks 
    3636; 
    3737 
    3838: empty-buffers   ( -- ) 
    3939   block-bufs /buffer #bufs * erase 
    40    #bufs 0 do  -1 i blk#!  loop 
     40   #bufs 0 do  -1. i d.blk#!  loop 
    4141   buf-table  #bufs 0 ?do  i 2dup + c!  loop  drop 
    4242; 
     
    6666   dup dirty? if                        ( buffer# ) 
    6767      false over dirty! 
    68       dup >buffer  swap blk#            ( buffer-adr block# ) 
    69       dup gds-fs-block# <=  if 
    70          dup . ." attempt to corrupt superblock or group descriptor" abort 
    71       then 
    72       bbug? if ." W " dup . cr then 
    73       write-fs-block abort" write error " 
     68      dup >buffer  swap d.blk#          ( buffer-adr d.block# ) 
     69      2dup d.gds-fs-block# d<=  if      ( buffer-adr d.block# ) 
     70         2dup d. ." attempt to corrupt superblock or group descriptor" abort 
     71      then                              ( buffer-adr d.block# ) 
     72      bbug? if ." W " 2dup d. cr then   ( buffer-adr d.block# ) 
     73      d.write-fs-block abort" write error " 
    7474   else 
    7575      drop 
     
    7878: flush   ( -- )   #bufs 0 ?do   i flush-buffer   loop  ; 
    7979 
    80 : (buffer)   ( block# -- buffer-adr in-buf? ) 
     80: d.(buffer)   ( d.block# -- buffer-adr in-buf? ) 
    8181   \ is the block already in a buffer? 
    82    0 
    83    begin                                        ( block# buf# ) 
    84       2dup blk# = if                    \ found it 
    85          nip  dup mru!  >buffer true exit 
    86       then 
    87        
    88       1+ dup #bufs = 
    89    until  drop                          \ not found     ( block# ) 
     82   #bufs 0  ?do                         ( d.block# ) 
     83      2dup i d.blk# d=  if  \ found it  ( d.block# ) 
     84         2drop  i mru!                  ( ) 
     85         i >buffer true unloop exit     ( -- buffer-adr true ) 
     86      then                              ( d.block# ) 
     87   loop                                 ( d.block# )       
    9088    
    9189   \ free up the least-recently-used buffer 
    92    lru dup flush-buffer                         ( block# buf# ) 
     90   lru dup flush-buffer                 ( d.block# buf# ) 
    9391    
    94    tuck blk#!   >buffer false                   ( buffer-adr ) 
     92   dup >r  d.blk#!                      ( r: buf# ) 
     93   r> >buffer false                     ( buffer-adr false ) 
    9594; 
    9695 
    97 : buffer   ( block# -- a )      \ like block, but does no reads 
    98    (buffer) drop 
     96: d.buffer   ( d.block# -- a )  \ like block, but does no reads 
     97   d.(buffer) drop 
    9998; 
    100 : block   ( block# -- a ) 
    101    dup (buffer) if  nip exit  then              ( block# buffer-adr ) 
    102     
    103    bbug? if ." r " over . cr then 
    104    dup rot read-fs-block abort" read error "    ( buffer-adr ) 
     99: d.block   ( d.block# -- a ) 
     100   2dup d.(buffer) if  nip nip exit  then               ( d.block# buffer-adr ) 
     101 
     102   bbug? if ." r " 2 pick over d. cr then               ( d.block# buffer-adr ) 
     103   dup 2swap d.read-fs-block abort" read error "        ( buffer-adr ) 
    105104; 
     105: block  ( block# -- a )  u>d d.block  ; 
    106106 
    107 : bd   ( n -- )   block bsize dump  ; 
     107: d.bd   ( d -- )   d.block bsize dump  ; 
    108108 
    109109\ LICENSE_BEGIN 
  • ofw/fs/ext2fs/dir.fth

    r1954 r2796  
    193193   \ Short symlinks hold no blocks, but have a string in the direct block list, 
    194194   \ so we must not interpret that string as a block list. 
    195    #blks-held  if  delete-blocks  then 
    196  
    197    \ clear #blks-held, link-count, etc. 
     195   d.#blks-held d0<>  if  delete-blocks  then 
     196 
     197   \ clear d.#blks-held, link-count, etc. 
    198198   0 +i  /inode  6 /l* /string erase 
    199199    
     
    258258 
    259259: linkpath   ( -- a ) 
    260    file-acl  if  bsize 9 rshift  else  0  then     ( #acl-blocks ) 
    261    #blks-held  <>  if   \ long symbolic link path 
     260   d.file-acl d0<>  if  bsize 9 rshift  else  0  then     ( #acl-blocks ) 
     261   u>d  d.#blks-held  d<>  if   \ long symbolic link path 
    262262      direct0 int@ block 
    263263   else                 \ short symbolic link path 
  • ofw/fs/ext2fs/inode.fth

    r1720 r2796  
    88 
    99: ipb   ( -- n )  bsize /inode /  ; 
    10 : itob  ( i# -- offset block# ) 
     10: d.itob  ( i# -- offset d.block# ) 
    1111   1- ipg /mod          ( rel-i# group ) 
    12    gpimin  swap         ( block# rel-i# ) 
    13    ipb /mod             ( gp-block# offset rel-blk# ) 
    14    blkstofrags 
    15    rot +                ( offset block# ) 
     12   d.gpimin  2>r        ( rel-i# r: d.iblock# ) 
     13   ipb /mod             ( offset rel-blk# r: d.iblock# ) 
     14   u>d 2r> d+           ( offset d.block# ) 
    1615; 
    1716 
    18 : inode  ( i# -- adr )   itob block swap /inode * +  ; 
     17: inode  ( i# -- adr )   d.itob d.block swap /inode * +  ; 
    1918: ind   ( n -- )  inode  /inode dump  ; 
    2019: +i  ( n -- )  inode# inode +  ; 
     
    3837: link-count  ( -- n )          26 +i short@  ; 
    3938: link-count! ( n -- )          26 +i short!  update  ; 
    40 : #blks-held  ( -- n )          28 +i int@  ; 
    41 : #blks-held! ( n -- )          28 +i int!  update  ; 
    42 : file-acl    ( -- n )         104 +i int@  ; 
    43 : dir-acl     ( -- n )         108 +i int@  ; 
     39 
     40: d.#blks-held  ( -- d ) 
     41   28 +i int@                                            ( n ) 
     42   \ Should be contingent on sb-huge-files? as below, but the field 
     43   \ at 116 was reserved before, so it's going to be 0 without huge files 
     44   116 +i short@                                         ( d ) 
     45\   sb-huge-files?  if  116 +i short@  else  u>d  then    ( d ) 
     46[ifdef] inode-huge? 
     47   \ I'm not supporting the representation where the inode block 
     48   \ count is in file system blocks instead of 512-byte blocks, 
     49   \ because I can't figure out how it works in the Linux kernel. 
     50   \ I can see how it works when updating an inode, but I don't 
     51   \ see how it works with an already-created file. 
     52   inode-huge?  if  logbsize 9 - dlshift  then           ( d' ) 
     53[then] 
     54; 
     55 
     56: d.#blks-held! ( d -- ) 
     57[ifdef] inode-huge? 
     58   2dup h# 1.0000.0000.0000. d>=  if     ( d ) 
     59      logbsize 9 - drshift               ( d' ) 
     60      set-inode-huge                     ( d ) 
     61   else                                  ( d ) 
     62      clear-inode-huge                   ( d ) 
     63   then                                  ( d ) 
     64[then] 
     65   116 +i short!  28 +i int!  update     ( ) 
     66; 
     67: d.file-acl    ( -- d )        104 +i int@  118 +i short@  ; 
     68\ : dir-acl     ( -- n )         108 +i int@  ; 
    4469 
    4570d# 12 constant #direct-blocks 
  • ofw/fs/ext2fs/layout.fth

    r2645 r2796  
    7878      nip 
    7979   else 
    80       drop add-block                    ( index new-block# ) 
     80      drop u.add-block                  ( index new-block# ) 
    8181      dup rot r@ block swap la+ int! update     ( new-block# ) 
    8282   then                                 ( block# ) 
     
    9090      nip 
    9191   else 
    92       drop add-block                    ( index-low index-high new-block# ) 
     92      drop u.add-block                  ( index-low index-high new-block# ) 
    9393      dup rot r@ block swap la+ int! update     ( index-low new-block# ) 
    9494   then                                 ( index-low block# ) 
     
    103103      nip 
    104104   else 
    105       drop add-block                    ( index-low index-high new-block# ) 
     105      drop u.add-block                  ( index-low index-high new-block# ) 
    106106      dup rot r@ block swap la+ int! update     ( index-low new-block# ) 
    107107   then                                 ( index-low block# ) 
     
    115115      dup get-direct ?dup  if  nip exit  then   ( lblk# ) 
    116116       
    117       add-block dup rot >direct int! update  exit 
     117      u.add-block dup rot >direct int! update  exit 
    118118   then                                         ( lblk# ) 
    119119   #direct-blocks -                             ( lblk#' ) 
     
    121121   dup #ind-blocks1 <  if                       ( lblk# ) 
    122122      #direct-blocks    get-direct ?dup 0=  if  ( lblk# ) 
    123          add-block  dup #direct-blocks put-direct 
     123         u.add-block  dup #direct-blocks put-direct 
    124124      then                                      ( lblk# block ) 
    125125      get-ind1  exit 
     
    129129   dup #ind-blocks2  <  if 
    130130      #direct-blocks 1+ get-direct ?dup 0=  if 
    131          add-block  dup #direct-blocks 1+ put-direct 
     131         u.add-block  dup #direct-blocks 1+ put-direct 
    132132      then                                      ( lblk# block ) 
    133133      get-ind2 exit 
     
    137137   dup #ind-blocks3  <  if 
    138138      #direct-blocks 2+ get-direct ?dup 0=  if 
    139          add-block  dup #direct-blocks 2+ put-direct 
     139         u.add-block  dup #direct-blocks 2+ put-direct 
    140140      then                                      ( lblk# block ) 
    141141      get-ind3 exit 
     
    148148 
    149149\ this code is a bit tricky, in that after deleting a block, 
    150 \ you must update the block which pointed to it. 
     150\ you must update the block that pointed to it. 
    151151 
    152152: del-blk0   ( a -- deleted? ) 
    153    int@ dup 0= if  exit  then   free-block  true 
     153   int@ dup 0= if  exit  then   n.free-block  true 
    154154; 
    155155: del-blk1   ( a -- deleted? ) 
     
    159159      dup block i + del-blk0 if  0 over block i + int! update  then 
    160160   4 +loop                                      ( blk# ) 
    161    free-block  true 
     161   n.free-block  true 
    162162; 
    163163: del-blk2   ( a -- deleted? ) 
     
    167167      dup block i + del-blk1 if  0 over block i + int! update  then 
    168168   4 +loop                                      ( blk# ) 
    169    free-block  true 
     169   n.free-block  true 
    170170; 
    171171: del-blk3   ( a -- deleted? ) 
     
    175175      dup block i + del-blk2 if  0 over block i + int! update  then 
    176176   4 +loop                                      ( blk# ) 
    177    free-block  true 
     177   n.free-block  true 
    178178; 
    179179: delete-directs   ( -- ) 
     
    190190 
    191191: append-block   ( -- ) 
    192    add-block                                            ( block ) 
     192   u.add-block                                          ( block ) 
    193193   dfile-size bsize um/mod nip  dup bsize um* dfile-size!       ( block #blocks ) 
    194194   1+ >pblk int! update 
     
    229229 
    230230   /gds do-alloc is gds 
    231    gds /gds gds-block# read-ublocks dup  if 
     231   gds /gds d.gds-block# d.read-ublocks dup  if 
    232232      gds         /gds          do-free 
    233233      super-block /super-block  do-free exit 
  • ofw/fs/ext2fs/methods.fth

    r2675 r2796  
    88external 
    99 
    10 : free-bytes  ( -- d )  total-free-blocks bsize um*  ; 
     10: free-bytes  ( -- d )  d.total-free-blocks bsize du*  ; 
    1111 
    1212: $create   ( name$ -- error? ) 
     
    1919   dirent-inode@ set-inode 
    2020 
    21    add-block                                    ( block# ) 
    22    dfile-size h# 400. d+ dfile-size!            ( block# ) 
    23    dup direct0 int! update                      ( block# ) 
    24    block bsize erase update  \  flush           ( ) 
     21   u.add-block                                  ( u.block# ) 
     22   dfile-size h# 400. d+ dfile-size!            ( u.block# ) 
     23   dup direct0 int! update                      ( u.block# ) 
     24   u>d d.block bsize erase update  \  flush     ( ) 
    2525   inode# first-dirent  if  true exit  then     ( ) 
    2626   " ."  bsize  inode#  fill-dirent             ( ) 
  • ofw/fs/ext2fs/recovery.fth

    r2675 r2796  
    133133 
    134134: write-jblock  ( d.block# adr -- ) 
    135    -rot drop write-fs-block     ( error? ) 
     135   -rot d.write-fs-block     ( error? ) 
    136136   if  ." Journal recovery write error" cr  abort  then 
    137137; 
  • ofw/fs/ext2fs/sb.fth

    r2645 r2796  
    3737\ ; 
    3838 
    39 : ceiling   ( nom div -- n )   /mod swap if  1+  then  ; 
     39: ceiling   ( nom div -- n )     ; 
    4040 
    4141\ : total-inodes                ( -- n )   0 +sbl  ; 
    42 : total-blocks          ( -- n )   1 +sbl  ; 
    43 : total-free-blocks     ( -- n )   3 +sbl  ; 
     42: d.total-blocks        ( -- d )   1 +sbl  84 +sbl  ; 
     43: d.total-free-blocks   ( -- d )   3 +sbl  86 +sbl  ; 
    4444\ : total-free-inodes   ( -- n )   4 +sbl  ; 
    4545\ : total-free-blocks+! ( -- n )   3 +sbl  +  super-block  3 la+ int!  ; 
    4646\ : total-free-inodes+! ( -- n )   4 +sbl  +  super-block  4 la+ int!  ; 
    47 : total-free-blocks!    ( -- n )   super-block  3 la+ int!  ; 
     47: d.total-free-blocks!  ( d -- )   super-block  tuck 86 la+ int!  3 la+ int!  ; 
    4848: total-free-inodes!    ( -- n )   super-block  4 la+ int!  ; 
    49 : #groups   ( -- n )   total-blocks bpg ceiling  ; 
     49: #groups   ( -- n )   d.total-blocks bpg um/mod swap  if  1+  then  ; 
    5050 
    5151: recover?  ( -- flag )  24 +sbl 4 and 0<>  ; 
     
    6565; 
    6666 
    67 : write-ublocks  ( adr len dev-block# -- error? ) 
    68    ublock um* " seek" $call-parent ?dup  if  exit  then         ( adr len ) 
     67: d.write-ublocks  ( adr len d.dev-block# -- error? ) 
     68   ublock du* " seek" $call-parent ?dup  if  exit  then         ( adr len ) 
    6969   tuck " write" $call-parent <> 
    7070; 
    7171: put-super-block  ( -- error? ) 
    72    super-block /super-block super-block# write-ublocks 
     72   super-block /super-block super-block# u>d d.write-ublocks 
    7373; 
    7474 
    75 : read-ublocks  ( adr len dev-block# -- error? ) 
    76    ublock um* " seek" $call-parent ?dup  if  exit  then         ( adr len ) 
     75: d.read-ublocks  ( adr len dev-block# -- error? ) 
     76   ublock du* " seek" $call-parent ?dup  if  exit  then         ( adr len ) 
    7777   tuck " read" $call-parent <> 
    7878; 
    7979 
    8080: get-super-block  ( -- error? ) 
    81    super-block /super-block super-block# read-ublocks ?dup  if  exit  then 
     81   super-block /super-block super-block# u>d d.read-ublocks ?dup  if  exit  then 
    8282 
    8383   ['] le-l@ to int@  ['] le-w@ to short@ 
     
    9090; 
    9191 
    92 : gds-fs-block#  ( -- fs-block# ) 
    93    datablock0 1+        ( logical-block# ) 
     92: d.gds-fs-block#  ( -- d.fs-block# ) 
     93   datablock0 1+ u>d    ( d.logical-block# ) 
    9494; 
    95 : gds-block#  ( -- dev-block# ) 
    96    gds-fs-block#  bsize ublock / *              ( dev-block# ) 
     95: d.gds-block#  ( -- d.dev-block# ) 
     96   d.gds-fs-block#  bsize ublock / du*          ( dev-block# ) 
    9797; 
    98 : /gds  ( -- size )  #groups h# 20 *  ublock round-up  ; 
    99 : group-desc  ( group# -- adr )  h# 20 *  gds +  ; 
    100 : gpimin    ( group -- block# )   group-desc  2 la+ int@  ; 
    101 : blkstofrags  ( #blocks -- #frags )  ;         \ XXX is this needed? 
     98: desc64?  ( -- flag )  h# 7f +sbw  0<>  ; 
     99: /gd  ( -- n )  h# 7f +sbw  ?dup 0=  if  h# 20  then  ; 
     100: /gds  ( -- size )  #groups /gd *  ublock round-up  ; 
     101: group-desc  ( group# -- adr )  /gd *  gds +  ; 
     102: d.gpimin    ( group -- d.block# ) 
     103   group-desc  dup  2 la+ int@  ( adr block# ) 
     104   desc64?  if  swap 9 la+ int@ else  nip 0  then  ( d.block# ) 
     105; 
    102106 
    103107 
Note: See TracChangeset for help on using the changeset viewer.