Changeset 2796


Ignore:
Timestamp:
Jan 3, 2012, 1:54:24 AM (4 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.