2.2.18-pre2-beos09032000.patch

   1 diff -aur --new-file linux-2.2.18-pre2-clean/Documentation/Configure.help linux-2.2.18-pre2-beos/Documentation/Configure.help
   2 --- linux-2.2.18-pre2-clean/Documentation/Configure.help        Thu Aug 24 01:54:28 2000
   3 +++ linux-2.2.18-pre2-beos/Documentation/Configure.help Sat Sep  2 12:54:02 2000
   4 @@ -7674,6 +7674,24 @@
   5  CONFIG_QNX4FS_RW
   6    Say Y if you want to test write support for QNX4 filesystems.
   7
   8 +BeOS filesystem support (EXPERIMENTAL)
   9 +CONFIG_BEOS_FS
  10 +  This is the filesystem used by the BeOS operating system. Say Y if
  11 +  you want to get read access to file on BeOS partitions of your hard
  12 +  drive or floppy disk.
  13 +
  14 +  This filesystem support is also available as a module ( = code which
  15 +  can be inserted in and removed from the running kernel whenever you
  16 +  want). The module is called beos.o. If you want to compile it as a
  17 +  module, say M here and read Documentation/modules.txt.
  18 +
  19 +  If unsure, say N.
  20 +
  21 +Other platform BeOS fs support
  22 +CONFIG_BEOS_CONV
  23 +  Say Y if you want to use other platform BeOS (i.e. mount BeOS(ppc) on
  24 +  Intel box).
  25 +
  26  Kernel automounter support
  27  CONFIG_AUTOFS_FS
  28    The automounter is a tool to automatically mount remote filesystems
  29 diff -aur --new-file linux-2.2.18-pre2-clean/fs/Config.in linux-2.2.18-pre2-beos/fs/Config.in
  30 --- linux-2.2.18-pre2-clean/fs/Config.in        Thu Aug 24 01:54:28 2000
  31 +++ linux-2.2.18-pre2-beos/fs/Config.in Sat Sep  2 12:51:25 2000
  32 @@ -47,6 +47,12 @@
  33      bool '   QNX4FS write support (DANGEROUS)' CONFIG_QNX4FS_RW
  34    fi
  35  fi
  36 +if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
  37 +  tristate 'BeOS filesystem support (read only) (EXPERIMENTAL)' CONFIG_BEOS_FS
  38 +  if [ "$CONFIG_BEOS_FS" != "n" ]; then
  39 +    bool '   BeOS other platform support' CONFIG_BEOS_CONV
  40 +  fi
  41 +fi
  42  tristate 'ROM filesystem support' CONFIG_ROMFS_FS
  43  tristate 'Second extended fs support' CONFIG_EXT2_FS
  44  tristate 'System V and Coherent filesystem support' CONFIG_SYSV_FS
  45 diff -aur --new-file linux-2.2.18-pre2-clean/fs/Makefile linux-2.2.18-pre2-beos/fs/Makefile
  46 --- linux-2.2.18-pre2-clean/fs/Makefile Thu Aug 24 01:54:28 2000
  47 +++ linux-2.2.18-pre2-beos/fs/Makefile  Sat Sep  2 12:51:47 2000
  48 @@ -18,7 +18,7 @@
  49  MOD_LIST_NAME := FS_MODULES
  50  ALL_SUB_DIRS = coda minix ext2 fat msdos vfat proc isofs nfs umsdos ntfs \
  51                 hpfs sysv smbfs ncpfs ufs affs romfs autofs hfs lockd \
  52 -               nfsd nls devpts adfs qnx4 efs
  53 +               nfsd nls devpts adfs qnx4 efs beos
  54
  55  ifeq ($(CONFIG_QUOTA),y)
  56  O_OBJS += dquot.o
  57 @@ -212,6 +212,14 @@
  58  else
  59    ifeq ($(CONFIG_QNX4FS_FS),m)
  60    MOD_SUB_DIRS += qnx4
  61 +  endif
  62 +endif
  63 +
  64 +ifeq ($(CONFIG_BEOS_FS),y)
  65 +SUB_DIRS += beos
  66 +else
  67 +  ifeq ($(CONFIG_BEOS_FS),m)
  68 +  MOD_SUB_DIRS += beos
  69    endif
  70  endif
  71
  72 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/COPYING linux-2.2.18-pre2-beos/fs/beos/COPYING
  73 --- linux-2.2.18-pre2-clean/fs/beos/COPYING     Wed Dec 31 18:00:00 1969
  74 +++ linux-2.2.18-pre2-beos/fs/beos/COPYING      Thu May 20 05:41:55 1999
  75 @@ -0,0 +1,339 @@
  76 +                   GNU GENERAL PUBLIC LICENSE
  77 +                      Version 2, June 1991
  78 +
  79 + Copyright (C) 1989, 1991 Free Software Foundation, Inc.
  80 +                          675 Mass Ave, Cambridge, MA 02139, USA
  81 + Everyone is permitted to copy and distribute verbatim copies
  82 + of this license document, but changing it is not allowed.
  83 +
  84 +                           Preamble
  85 +
  86 +  The licenses for most software are designed to take away your
  87 +freedom to share and change it.  By contrast, the GNU General Public
  88 +License is intended to guarantee your freedom to share and change free
  89 +software--to make sure the software is free for all its users.  This
  90 +General Public License applies to most of the Free Software
  91 +Foundation's software and to any other program whose authors commit to
  92 +using it.  (Some other Free Software Foundation software is covered by
  93 +the GNU Library General Public License instead.)  You can apply it to
  94 +your programs, too.
  95 +
  96 +  When we speak of free software, we are referring to freedom, not
  97 +price.  Our General Public Licenses are designed to make sure that you
  98 +have the freedom to distribute copies of free software (and charge for
  99 +this service if you wish), that you receive source code or can get it
 100 +if you want it, that you can change the software or use pieces of it
 101 +in new free programs; and that you know you can do these things.
 102 +
 103 +  To protect your rights, we need to make restrictions that forbid
 104 +anyone to deny you these rights or to ask you to surrender the rights.
 105 +These restrictions translate to certain responsibilities for you if you
 106 +distribute copies of the software, or if you modify it.
 107 +
 108 +  For example, if you distribute copies of such a program, whether
 109 +gratis or for a fee, you must give the recipients all the rights that
 110 +you have.  You must make sure that they, too, receive or can get the
 111 +source code.  And you must show them these terms so they know their
 112 +rights.
 113 +
 114 +  We protect your rights with two steps: (1) copyright the software, and
 115 +(2) offer you this license which gives you legal permission to copy,
 116 +distribute and/or modify the software.
 117 +
 118 +  Also, for each author's protection and ours, we want to make certain
 119 +that everyone understands that there is no warranty for this free
 120 +software.  If the software is modified by someone else and passed on, we
 121 +want its recipients to know that what they have is not the original, so
 122 +that any problems introduced by others will not reflect on the original
 123 +authors' reputations.
 124 +
 125 +  Finally, any free program is threatened constantly by software
 126 +patents.  We wish to avoid the danger that redistributors of a free
 127 +program will individually obtain patent licenses, in effect making the
 128 +program proprietary.  To prevent this, we have made it clear that any
 129 +patent must be licensed for everyone's free use or not licensed at all.
 130 +
 131 +  The precise terms and conditions for copying, distribution and
 132 +modification follow.
 133 +\f
 134 +                   GNU GENERAL PUBLIC LICENSE
 135 +   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 136 +
 137 +  0. This License applies to any program or other work which contains
 138 +a notice placed by the copyright holder saying it may be distributed
 139 +under the terms of this General Public License.  The "Program", below,
 140 +refers to any such program or work, and a "work based on the Program"
 141 +means either the Program or any derivative work under copyright law:
 142 +that is to say, a work containing the Program or a portion of it,
 143 +either verbatim or with modifications and/or translated into another
 144 +language.  (Hereinafter, translation is included without limitation in
 145 +the term "modification".)  Each licensee is addressed as "you".
 146 +
 147 +Activities other than copying, distribution and modification are not
 148 +covered by this License; they are outside its scope.  The act of
 149 +running the Program is not restricted, and the output from the Program
 150 +is covered only if its contents constitute a work based on the
 151 +Program (independent of having been made by running the Program).
 152 +Whether that is true depends on what the Program does.
 153 +
 154 +  1. You may copy and distribute verbatim copies of the Program's
 155 +source code as you receive it, in any medium, provided that you
 156 +conspicuously and appropriately publish on each copy an appropriate
 157 +copyright notice and disclaimer of warranty; keep intact all the
 158 +notices that refer to this License and to the absence of any warranty;
 159 +and give any other recipients of the Program a copy of this License
 160 +along with the Program.
 161 +
 162 +You may charge a fee for the physical act of transferring a copy, and
 163 +you may at your option offer warranty protection in exchange for a fee.
 164 +
 165 +  2. You may modify your copy or copies of the Program or any portion
 166 +of it, thus forming a work based on the Program, and copy and
 167 +distribute such modifications or work under the terms of Section 1
 168 +above, provided that you also meet all of these conditions:
 169 +
 170 +    a) You must cause the modified files to carry prominent notices
 171 +    stating that you changed the files and the date of any change.
 172 +
 173 +    b) You must cause any work that you distribute or publish, that in
 174 +    whole or in part contains or is derived from the Program or any
 175 +    part thereof, to be licensed as a whole at no charge to all third
 176 +    parties under the terms of this License.
 177 +
 178 +    c) If the modified program normally reads commands interactively
 179 +    when run, you must cause it, when started running for such
 180 +    interactive use in the most ordinary way, to print or display an
 181 +    announcement including an appropriate copyright notice and a
 182 +    notice that there is no warranty (or else, saying that you provide
 183 +    a warranty) and that users may redistribute the program under
 184 +    these conditions, and telling the user how to view a copy of this
 185 +    License.  (Exception: if the Program itself is interactive but
 186 +    does not normally print such an announcement, your work based on
 187 +    the Program is not required to print an announcement.)
 188 +\f
 189 +These requirements apply to the modified work as a whole.  If
 190 +identifiable sections of that work are not derived from the Program,
 191 +and can be reasonably considered independent and separate works in
 192 +themselves, then this License, and its terms, do not apply to those
 193 +sections when you distribute them as separate works.  But when you
 194 +distribute the same sections as part of a whole which is a work based
 195 +on the Program, the distribution of the whole must be on the terms of
 196 +this License, whose permissions for other licensees extend to the
 197 +entire whole, and thus to each and every part regardless of who wrote it.
 198 +
 199 +Thus, it is not the intent of this section to claim rights or contest
 200 +your rights to work written entirely by you; rather, the intent is to
 201 +exercise the right to control the distribution of derivative or
 202 +collective works based on the Program.
 203 +
 204 +In addition, mere aggregation of another work not based on the Program
 205 +with the Program (or with a work based on the Program) on a volume of
 206 +a storage or distribution medium does not bring the other work under
 207 +the scope of this License.
 208 +
 209 +  3. You may copy and distribute the Program (or a work based on it,
 210 +under Section 2) in object code or executable form under the terms of
 211 +Sections 1 and 2 above provided that you also do one of the following:
 212 +
 213 +    a) Accompany it with the complete corresponding machine-readable
 214 +    source code, which must be distributed under the terms of Sections
 215 +    1 and 2 above on a medium customarily used for software interchange; or,
 216 +
 217 +    b) Accompany it with a written offer, valid for at least three
 218 +    years, to give any third party, for a charge no more than your
 219 +    cost of physically performing source distribution, a complete
 220 +    machine-readable copy of the corresponding source code, to be
 221 +    distributed under the terms of Sections 1 and 2 above on a medium
 222 +    customarily used for software interchange; or,
 223 +
 224 +    c) Accompany it with the information you received as to the offer
 225 +    to distribute corresponding source code.  (This alternative is
 226 +    allowed only for noncommercial distribution and only if you
 227 +    received the program in object code or executable form with such
 228 +    an offer, in accord with Subsection b above.)
 229 +
 230 +The source code for a work means the preferred form of the work for
 231 +making modifications to it.  For an executable work, complete source
 232 +code means all the source code for all modules it contains, plus any
 233 +associated interface definition files, plus the scripts used to
 234 +control compilation and installation of the executable.  However, as a
 235 +special exception, the source code distributed need not include
 236 +anything that is normally distributed (in either source or binary
 237 +form) with the major components (compiler, kernel, and so on) of the
 238 +operating system on which the executable runs, unless that component
 239 +itself accompanies the executable.
 240 +
 241 +If distribution of executable or object code is made by offering
 242 +access to copy from a designated place, then offering equivalent
 243 +access to copy the source code from the same place counts as
 244 +distribution of the source code, even though third parties are not
 245 +compelled to copy the source along with the object code.
 246 +\f
 247 +  4. You may not copy, modify, sublicense, or distribute the Program
 248 +except as expressly provided under this License.  Any attempt
 249 +otherwise to copy, modify, sublicense or distribute the Program is
 250 +void, and will automatically terminate your rights under this License.
 251 +However, parties who have received copies, or rights, from you under
 252 +this License will not have their licenses terminated so long as such
 253 +parties remain in full compliance.
 254 +
 255 +  5. You are not required to accept this License, since you have not
 256 +signed it.  However, nothing else grants you permission to modify or
 257 +distribute the Program or its derivative works.  These actions are
 258 +prohibited by law if you do not accept this License.  Therefore, by
 259 +modifying or distributing the Program (or any work based on the
 260 +Program), you indicate your acceptance of this License to do so, and
 261 +all its terms and conditions for copying, distributing or modifying
 262 +the Program or works based on it.
 263 +
 264 +  6. Each time you redistribute the Program (or any work based on the
 265 +Program), the recipient automatically receives a license from the
 266 +original licensor to copy, distribute or modify the Program subject to
 267 +these terms and conditions.  You may not impose any further
 268 +restrictions on the recipients' exercise of the rights granted herein.
 269 +You are not responsible for enforcing compliance by third parties to
 270 +this License.
 271 +
 272 +  7. If, as a consequence of a court judgment or allegation of patent
 273 +infringement or for any other reason (not limited to patent issues),
 274 +conditions are imposed on you (whether by court order, agreement or
 275 +otherwise) that contradict the conditions of this License, they do not
 276 +excuse you from the conditions of this License.  If you cannot
 277 +distribute so as to satisfy simultaneously your obligations under this
 278 +License and any other pertinent obligations, then as a consequence you
 279 +may not distribute the Program at all.  For example, if a patent
 280 +license would not permit royalty-free redistribution of the Program by
 281 +all those who receive copies directly or indirectly through you, then
 282 +the only way you could satisfy both it and this License would be to
 283 +refrain entirely from distribution of the Program.
 284 +
 285 +If any portion of this section is held invalid or unenforceable under
 286 +any particular circumstance, the balance of the section is intended to
 287 +apply and the section as a whole is intended to apply in other
 288 +circumstances.
 289 +
 290 +It is not the purpose of this section to induce you to infringe any
 291 +patents or other property right claims or to contest validity of any
 292 +such claims; this section has the sole purpose of protecting the
 293 +integrity of the free software distribution system, which is
 294 +implemented by public license practices.  Many people have made
 295 +generous contributions to the wide range of software distributed
 296 +through that system in reliance on consistent application of that
 297 +system; it is up to the author/donor to decide if he or she is willing
 298 +to distribute software through any other system and a licensee cannot
 299 +impose that choice.
 300 +
 301 +This section is intended to make thoroughly clear what is believed to
 302 +be a consequence of the rest of this License.
 303 +\f
 304 +  8. If the distribution and/or use of the Program is restricted in
 305 +certain countries either by patents or by copyrighted interfaces, the
 306 +original copyright holder who places the Program under this License
 307 +may add an explicit geographical distribution limitation excluding
 308 +those countries, so that distribution is permitted only in or among
 309 +countries not thus excluded.  In such case, this License incorporates
 310 +the limitation as if written in the body of this License.
 311 +
 312 +  9. The Free Software Foundation may publish revised and/or new versions
 313 +of the General Public License from time to time.  Such new versions will
 314 +be similar in spirit to the present version, but may differ in detail to
 315 +address new problems or concerns.
 316 +
 317 +Each version is given a distinguishing version number.  If the Program
 318 +specifies a version number of this License which applies to it and "any
 319 +later version", you have the option of following the terms and conditions
 320 +either of that version or of any later version published by the Free
 321 +Software Foundation.  If the Program does not specify a version number of
 322 +this License, you may choose any version ever published by the Free Software
 323 +Foundation.
 324 +
 325 +  10. If you wish to incorporate parts of the Program into other free
 326 +programs whose distribution conditions are different, write to the author
 327 +to ask for permission.  For software which is copyrighted by the Free
 328 +Software Foundation, write to the Free Software Foundation; we sometimes
 329 +make exceptions for this.  Our decision will be guided by the two goals
 330 +of preserving the free status of all derivatives of our free software and
 331 +of promoting the sharing and reuse of software generally.
 332 +
 333 +                           NO WARRANTY
 334 +
 335 +  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 336 +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 337 +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 338 +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 339 +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 340 +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 341 +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 342 +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 343 +REPAIR OR CORRECTION.
 344 +
 345 +  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 346 +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 347 +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 348 +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 349 +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 350 +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 351 +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 352 +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 353 +POSSIBILITY OF SUCH DAMAGES.
 354 +
 355 +                    END OF TERMS AND CONDITIONS
 356 +\f
 357 +           How to Apply These Terms to Your New Programs
 358 +
 359 +  If you develop a new program, and you want it to be of the greatest
 360 +possible use to the public, the best way to achieve this is to make it
 361 +free software which everyone can redistribute and change under these terms.
 362 +
 363 +  To do so, attach the following notices to the program.  It is safest
 364 +to attach them to the start of each source file to most effectively
 365 +convey the exclusion of warranty; and each file should have at least
 366 +the "copyright" line and a pointer to where the full notice is found.
 367 +
 368 +    <one line to give the program's name and a brief idea of what it does.>
 369 +    Copyright (C) 19yy  <name of author>
 370 +
 371 +    This program is free software; you can redistribute it and/or modify
 372 +    it under the terms of the GNU General Public License as published by
 373 +    the Free Software Foundation; either version 2 of the License, or
 374 +    (at your option) any later version.
 375 +
 376 +    This program is distributed in the hope that it will be useful,
 377 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
 378 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 379 +    GNU General Public License for more details.
 380 +
 381 +    You should have received a copy of the GNU General Public License
 382 +    along with this program; if not, write to the Free Software
 383 +    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 384 +
 385 +Also add information on how to contact you by electronic and paper mail.
 386 +
 387 +If the program is interactive, make it output a short notice like this
 388 +when it starts in an interactive mode:
 389 +
 390 +    Gnomovision version 69, Copyright (C) 19yy name of author
 391 +    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
 392 +    This is free software, and you are welcome to redistribute it
 393 +    under certain conditions; type `show c' for details.
 394 +
 395 +The hypothetical commands `show w' and `show c' should show the appropriate
 396 +parts of the General Public License.  Of course, the commands you use may
 397 +be called something other than `show w' and `show c'; they could even be
 398 +mouse-clicks or menu items--whatever suits your program.
 399 +
 400 +You should also get your employer (if you work as a programmer) or your
 401 +school, if any, to sign a "copyright disclaimer" for the program, if
 402 +necessary.  Here is a sample; alter the names:
 403 +
 404 +  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
 405 +  `Gnomovision' (which makes passes at compilers) written by James Hacker.
 406 +
 407 +  <signature of Ty Coon>, 1 April 1989
 408 +  Ty Coon, President of Vice
 409 +
 410 +This General Public License does not permit incorporating your program into
 411 +proprietary programs.  If your program is a subroutine library, you may
 412 +consider it more useful to permit linking proprietary applications with the
 413 +library.  If this is what you want to do, use the GNU Library General
 414 +Public License instead of this License.
 415 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/ChangeLog linux-2.2.18-pre2-beos/fs/beos/ChangeLog
 416 --- linux-2.2.18-pre2-clean/fs/beos/ChangeLog   Wed Dec 31 18:00:00 1969
 417 +++ linux-2.2.18-pre2-beos/fs/beos/ChangeLog    Sat Sep  2 12:57:10 2000
 418 @@ -0,0 +1,29 @@
 419 +2000-09-02
 420 +==========
 421 +o Fixed nls conversion routines and changed type of lookup function to
 422 +  dentry
 423 +
 424 +2000-08-16
 425 +==========
 426 +o Modified all to be called beos instead of bfs for future use with 2.4
 427 +  kernels.
 428 +o Mods to compile/work with 2.2.18-pre2 by Miles Lott <milos@insync.net>
 429 +
 430 +1999-05-25
 431 +==========
 432 +o Added BEOS(ppc) support.
 433 +o Added LinuxPPC support.
 434 +o Added nls (native language support).
 435 +o Fixed using blocksize other than 1024 bytes.
 436 +o Fixed memory leaks.
 437 +o Fixed many bugs.
 438 +
 439 +1999-02-21
 440 +==========
 441 +o Added mount option "uid" and "gid".
 442 +o Added symbolic link support.
 443 +o Fixed many bugs.
 444 +
 445 +1999-02-14
 446 +==========
 447 +o Release first alpha version.
 448 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/Makefile linux-2.2.18-pre2-beos/fs/beos/Makefile
 449 --- linux-2.2.18-pre2-clean/fs/beos/Makefile    Wed Dec 31 18:00:00 1969
 450 +++ linux-2.2.18-pre2-beos/fs/beos/Makefile     Thu Aug 24 10:45:24 2000
 451 @@ -0,0 +1,15 @@
 452 +#
 453 +# Makefile for the linux BEOS-filesystem routines.
 454 +#
 455 +# Note! Dependencies are done automagically by 'make dep', which also
 456 +# removes any old dependencies. DON'T put your own dependencies here
 457 +# unless it's something special (ie not a .c file).
 458 +#
 459 +# Note 2! The CFLAGS definitions are now in the main makefile...
 460 +
 461 +O_TARGET := beos.o
 462 +O_OBJS   := dir.o file.o inode.o namei.o super.o index.o debug.o symlink.o \
 463 +            util.o
 464 +M_OBJS   := $(O_TARGET)
 465 +
 466 +include $(TOPDIR)/Rules.make
 467 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/README linux-2.2.18-pre2-beos/fs/beos/README
 468 --- linux-2.2.18-pre2-clean/fs/beos/README      Wed Dec 31 18:00:00 1969
 469 +++ linux-2.2.18-pre2-beos/fs/beos/README       Thu Aug 24 10:45:24 2000
 470 @@ -0,0 +1,87 @@
 471 +BEOS filesystem for Linux  1999-05-28
 472 +
 473 +
 474 +WARNING
 475 +=======
 476 +Make sure you understand that this is alpha software.  This means that the
 477 +implementation is neither complete nor well-tested.  So using this driver,
 478 +by own risk.
 479 +
 480 +
 481 +WHAT'S THIS DRIVER
 482 +==================
 483 +This module is BEOS(filesystem of BeOS operating system) driver for Linux
 484 +2.2.x / 2.3.x.  Current version supports BEOS(x86) and BEOS(ppc).
 485 +
 486 +
 487 +HOW TO INSTALL
 488 +==============
 489 +step 1.  Install sources code to source code tree of linux.
 490 +
 491 +  i.e.
 492 +    cd /usr/src/linux
 493 +    tar ~/beos-YYYYMMDD.tar.gz
 494 +    patch -p1 < linux-2.2.x.patch
 495 +
 496 +step 2.  Configuretion & make kernel
 497 +
 498 +  i.e.
 499 +    make config
 500 +    make dep; make clean
 501 +    make bzImage
 502 +    make modules
 503 +
 504 +  Note that at 'BEOS Filesystem support', you should answer y(es) ori
 505 +  m(odule).  If you want to use other platform BEOS, you should answer
 506 +  y(es) aginst 'Other platform BEOS support'.
 507 +
 508 +step 3.  Install
 509 +
 510 +  i.e.
 511 +    cp /usr/src/arch/i386/boot/zImage /vmlinuz
 512 +    make modules_install
 513 +
 514 +
 515 +USING BEOS
 516 +=========
 517 +To use the BEOS filesystem, use filesystem type 'beos'.
 518 +
 519 +ex)
 520 +    mount -t beos -o type=x86,iocharset=iso8859-1 /dev/fd0 /beos
 521 +
 522 +
 523 +MOUNT OPTIONS
 524 +=============
 525 +uid=nnn             All files in the partition will be owned by user id nnn.
 526 +gid=nnn                    All files in the partition will be in group nnn.
 527 +type=nnn            Set filesystem type.  nnn is x86 or ppc. Default value is
 528 +                    platform depends (linux-x86 is x86, linux-ppc is ppc).
 529 +iocharset=nnn       charactor-set. But not support DBCS.
 530 +
 531 +
 532 +KNOWLEDGE ISSUE
 533 +===============
 534 +o Current implement supports read-only.
 535 +
 536 +
 537 +HOW TO GET LASTEST VERSION
 538 +==========================
 539 +The source and more information can be found in
 540 +
 541 +  http://hp.vector.co.jp/authors/VA008030/beos/
 542 +
 543 +
 544 +SPECIAL THANKS
 545 +==============
 546 +Dominic Giampalo ... writing "Practical file system design with Be file
 547 +                     system"
 548 +Hiroyuki Yamada  ... testing LinuxPPC.
 549 +
 550 +
 551 +AUTHOR
 552 +======
 553 +Makoto Kato <m_kato@ga2.so-net.ne.jp>
 554 +
 555 +MAINTAINER
 556 +==========
 557 +Miles Lott <milos@insync.net>
 558 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/debug.c linux-2.2.18-pre2-beos/fs/beos/debug.c
 559 --- linux-2.2.18-pre2-clean/fs/beos/debug.c     Wed Dec 31 18:00:00 1969
 560 +++ linux-2.2.18-pre2-beos/fs/beos/debug.c      Sat Aug 26 09:53:07 2000
 561 @@ -0,0 +1,177 @@
 562 +/*
 563 + *  linux/fs/beos/debug.c
 564 + *
 565 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
 566 + *
 567 + * debug functions
 568 + */
 569 +
 570 +#include <stdarg.h>
 571 +#include <linux/kernel.h>
 572 +#include <linux/fs.h>
 573 +//#include <linux/beos_fs.h>
 574 +
 575 +#ifdef BEOS_DEBUG
 576 +
 577 +
 578 +void beos_dump_inode (beos_inode * inode)
 579 +{
 580 +       int i, j;
 581 +
 582 +       printk (" beos_inode infomation\n");
 583 +
 584 +       for (i = 0; i < sizeof(beos_inode); i += 16) {
 585 +               printk ("  %04x:", i);
 586 +               for (j = 0; j < 16; j++) {
 587 +                       printk (" %02x", *(((char*) inode) + i + j) & 0xff);
 588 +               }
 589 +               printk ("\n");
 590 +       }
 591 +
 592 +       printk ("  magic1 %08x\n", inode->magic1);
 593 +       printk ("  inode_num %lu, %u %u\n", inode->inode_num.allocation_group,
 594 +               inode->inode_num.start, inode->inode_num.len);
 595 +       printk ("  uid %lu\n", inode->uid);
 596 +       printk ("  gid %lu\n", inode->gid);
 597 +       printk ("  mode %08x\n", inode->mode);
 598 +       printk ("  flags %08x\n", inode->flags);
 599 +       printk ("  create_time %u\n", inode->create_time >> 8);
 600 +       printk ("  last_modified_time %u\n", inode->last_modified_time >> 8);
 601 +       printk ("  parent %lu, %u, %u\n", inode->parent.allocation_group,
 602 +               inode->parent.start, inode->parent.len);
 603 +       printk ("  attributes %lu, %u, %u\n",
 604 +               inode->attributes.allocation_group,
 605 +               inode->attributes.start, inode->attributes.len);
 606 +       printk ("  type %08x\n", inode->type);
 607 +       printk ("  inode_size %lu\n", inode->inode_size);
 608 +
 609 +       if (S_ISLNK(inode->mode)) {
 610 +
 611 +               /*
 612 +                * This is symbolic link.
 613 +                */
 614 +
 615 +               printk ("  Symbolic link [%s]\n", inode->data.symlink);
 616 +       } else {
 617 +               int i;
 618 +
 619 +               for (i = 0; i < BEOS_NUM_DIRECT_BLOCKS; i++) {
 620 +                       printk ("  direct %d [%lu, %u, %u]\n",
 621 +                               inode->data.datastream.direct[i].allocation_group,
 622 +                               inode->data.datastream.direct[i].start,
 623 +                               inode->data.datastream.direct[i].len);
 624 +               }
 625 +               printk ("  max_direct_range %Lu\n",
 626 +                       inode->data.datastream.max_direct_range);
 627 +               printk ("  indirect [%lu, %u, %u]\n",
 628 +                       inode->data.datastream.indirect.allocation_group,
 629 +                       inode->data.datastream.indirect.start,
 630 +                       inode->data.datastream.indirect.len);
 631 +               printk ("  max_indirect_range %016X\n",
 632 +                       inode->data.datastream.max_indirect_range);
 633 +               printk ("  double indirect [%lu, %u, %u]\n",
 634 +                       inode->data.datastream.double_indirect.allocation_group,
 635 +                       inode->data.datastream.double_indirect.start,
 636 +                       inode->data.datastream.double_indirect.len);
 637 +               printk ("  max_double_indirect_range %016X\n",
 638 +                       inode->data.datastream.max_double_indirect_range);
 639 +               printk ("  size %016X\n",
 640 +                       inode->data.datastream.size);
 641 +       }
 642 +}
 643 +
 644 +
 645 +/*
 646 + * Display super block structure for debug.
 647 + */
 648 +
 649 +void beos_dump_super_block (beos_super_block * bs)
 650 +{
 651 +       int i, j;
 652 +
 653 +       printk (" beos_super_block information\n");
 654 +
 655 +       for (i = 0; i < sizeof(beos_super_block); i += 16) {
 656 +               printk ("  %04x:", i);
 657 +               for (j = 0; j < 16; j++) {
 658 +                       printk (" %02x", *(((char*) bs) + i + j) & 0xff);
 659 +               }
 660 +               printk ("\n");
 661 +       }
 662 +
 663 +       printk ("  name %s\n", bs->name);
 664 +       printk ("  magic1 %08x\n", bs->magic1);
 665 +       printk ("  fs_byte_order %08x\n", bs->fs_byte_order);
 666 +
 667 +       printk ("  block_size %lu\n", bs->block_size);
 668 +       printk ("  block_shift %lu\n", bs->block_shift);
 669 +
 670 +       printk ("  num_blocks %016X\n", bs->num_blocks);
 671 +       for (i = 0; i < sizeof(beos_off_t); i++) {
 672 +               printk( " %02x", *(((char*) &bs->num_blocks) + i) & 0xff);
 673 +       }
 674 +       printk ("\n  used_blocks %016X\n", bs->used_blocks);
 675 +
 676 +       printk ("  magic2 %08x\n", bs->magic2);
 677 +       printk ("  blocks_per_ag %lu\n", bs->blocks_per_ag);
 678 +       printk ("  ag_shift %lu\n", bs->ag_shift);
 679 +       printk ("  num_ags %lu\n", bs->num_ags);
 680 +
 681 +       printk ("  flags %08x\n", bs->flags);
 682 +
 683 +       printk ("  log_blocks %lu, %u, %u\n",
 684 +               bs->log_blocks.allocation_group,
 685 +               bs->log_blocks.start, bs->log_blocks.len);
 686 +       printk ("  log_start %Ld\n", bs->log_start);
 687 +       printk ("  log_end %Ld\n", bs->log_end);
 688 +
 689 +       printk ("  magic3 %08x\n", bs->magic3);
 690 +       printk ("  root_dir %lu, %u, %u\n",
 691 +               bs->root_dir.allocation_group, bs->root_dir.start,
 692 +               bs->root_dir.len);
 693 +       printk ("  indices %lu, %u, %u\n",
 694 +               bs->indices.allocation_group, bs->indices.start,
 695 +               bs->indices.len);
 696 +}
 697 +
 698 +
 699 +
 700 +void beos_dump_small_data (beos_small_data * sd)
 701 +{
 702 +}
 703 +
 704 +
 705 +
 706 +void beos_dump_inode_addr (beos_inode_addr iaddr)
 707 +{
 708 +       printk (" inode addr [%lu, %u, %u]\n",
 709 +               iaddr.allocation_group, iaddr.start, iaddr.len);
 710 +}
 711 +
 712 +
 713 +
 714 +void beos_dump_index_entry (beos_index_entry * entry)
 715 +{
 716 +       printk (" index entry structure\n");
 717 +       printk ("  magic %08x\n", entry->magic);
 718 +       printk ("  node_size %lu\n", entry->node_size);
 719 +       printk ("  max_number_of_levels %08x\n",
 720 +               entry->max_number_of_levels);
 721 +       printk ("  data_type %08x\n", entry->data_type);
 722 +       printk ("  root_node_pointer %016X\n", entry->root_node_pointer);
 723 +       printk ("  free_node_pointer %016X\n", entry->free_node_pointer);
 724 +       printk ("  maximum size %016X\n", entry->maximum_size);
 725 +}
 726 +
 727 +
 728 +void beos_dump_index_node (beos_index_node * node)
 729 +{
 730 +       printk (" inode of index node structure\n");
 731 +       printk ("  left %016X\n", node->left);
 732 +       printk ("  right %016X\n", node->right);
 733 +       printk ("  overflow %016X\n", node->overflow);
 734 +       printk ("  all_key_count %u\n", node->all_key_count);
 735 +       printk ("  all_key_length %u\n", node->all_key_length);
 736 +}
 737 +
 738 +#endif
 739 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/dir.c linux-2.2.18-pre2-beos/fs/beos/dir.c
 740 --- linux-2.2.18-pre2-clean/fs/beos/dir.c       Wed Dec 31 18:00:00 1969
 741 +++ linux-2.2.18-pre2-beos/fs/beos/dir.c        Sat Sep  2 12:29:12 2000
 742 @@ -0,0 +1,222 @@
 743 +/*
 744 + *  linux/fs/beos/dir.c
 745 + *
 746 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
 747 + *
 748 + *  from
 749 + *
 750 + *  linux/fs/minix/dir.c
 751 + *
 752 + *  Copyright (C) 1991, 1992  Linus Torvalds
 753 + */
 754 +
 755 +#include <asm/uaccess.h>
 756 +
 757 +#include <linux/errno.h>
 758 +#include <linux/fs.h>
 759 +#include <linux/sched.h>
 760 +#include <linux/stat.h>
 761 +#include <linux/mm.h>
 762 +#include <linux/nls.h>
 763 +
 764 +
 765 +static ssize_t beos_dir_read (struct file * filp, char * buf, size_t count,
 766 +       loff_t *ppos)
 767 +{
 768 +       return -EISDIR;
 769 +}
 770 +
 771 +
 772 +static int beos_readdir(struct file *, void *, filldir_t);
 773 +
 774 +static struct file_operations beos_dir_operations = {
 775 +       NULL,           /* lseek - default */
 776 +       beos_dir_read,
 777 +       NULL,           /* write - bad */
 778 +       beos_readdir,
 779 +       NULL,           /* poll - default */
 780 +       NULL,           /* ioctl */
 781 +       NULL,           /* mmap */
 782 +       NULL,           /* no special open code */
 783 +       NULL,           /* flush */
 784 +       NULL,           /* no special release code */
 785 +       file_fsync,
 786 +       NULL,           /* fasync */
 787 +       NULL,           /* check_media_change */
 788 +       NULL            /* revalidate */
 789 +};
 790 +
 791 +
 792 +/*
 793 + * directories can handle most operations...
 794 + */
 795 +
 796 +struct inode_operations beos_dir_inode_operations = {
 797 +       &beos_dir_operations,   /* default directory file-ops */
 798 +       NULL,                   /* create */
 799 +       &beos_lookup,           /* lookup */
 800 +       NULL,                   /* link */
 801 +       NULL,                   /* unlink */
 802 +       NULL,                   /* symlink */
 803 +       NULL,                   /* mkdir */
 804 +       NULL,                   /* rmdir */
 805 +       NULL,                   /* mknod */
 806 +       NULL,                   /* rename */
 807 +       NULL,                   /* readlink */
 808 +       NULL,                   /* follow_link */
 809 +       NULL,                   /* readpage */
 810 +       NULL,                   /* writepage */
 811 +       NULL,                   /* bmap */
 812 +       NULL,                   /* truncate */
 813 +       NULL,                   /* permission */
 814 +       NULL                    /* smap */
 815 +};
 816 +
 817 +
 818 +/*
 819 + * description:
 820 + *  A directory structure of BEOS became index structure.
 821 + *
 822 + *  struct beos_index_node
 823 + *  {
 824 + *   off_t  left_link;
 825 + *   off_t  right_link;
 826 + *   off_t  overflow_link;
 827 + *   short  all_node_count;
 828 + *   short  all_key_length
 829 + *   byte   key_data[all_key_length]
 830 + *   short  key_index_count[all_node_count - 1]
 831 + *   off_t  values[all_node_count]
 832 + *  }
 833 + *
 834 + *  directry have above key.
 835 + *  [.] [..] [file and directry] ...
 836 + */
 837 +
 838 +static int beos_readdir(struct file * filp, void * dirent, filldir_t filldir)
 839 +{
 840 +       struct inode *       inode = filp->f_dentry->d_inode;
 841 +       struct super_block * sb = inode->i_sb;
 842 +       beos_inode_addr       iaddr;
 843 +       char *               tmpname;
 844 +       int                  error;
 845 +       int                  count = 0;
 846 +       int                  len;
 847 +       beos_data_stream *    ds;
 848 +       int                  pos = 0;
 849 +
 850 +       BEOS_OUTPUT (("---> beos_readdir() "
 851 +               "inode %ld filp->f_pos %lu\n",
 852 +               inode->i_ino, filp->f_pos));
 853 +
 854 +       if (!inode || !S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
 855 +               return -EBADF;
 856 +
 857 +       tmpname = (char *) __getname();
 858 +       if (!tmpname)
 859 +               return -ENOMEM;
 860 +
 861 +       ds = &inode->u.beos_i.i_data.ds;
 862 +
 863 +       while (pos >= 0) {
 864 +
 865 +               struct buffer_head * bh;
 866 +               beos_index_node *     bn;
 867 +               beos_off_t            value;
 868 +               int                  flags;
 869 +               int                  k;
 870 +               beos_off_t            offset;
 871 +               char *               tmpname2;
 872 +               int                  len_dist;
 873 +
 874 +               if (pos)
 875 +                       flags = 1;
 876 +               else
 877 +                       flags = 0;
 878 +
 879 +               iaddr = beos_read_data_stream (sb, ds, &pos);
 880 +               if (!pos || BEOS_IS_EMPTY_IADDR(&iaddr))
 881 +                       break;
 882 +
 883 +               /*
 884 +                * read index node
 885 +                */
 886 +
 887 +               bh = beos_read_index_node (iaddr, sb, flags, &offset);
 888 +               if (!bh) {
 889 +
 890 +                       BEOS_OUTPUT (("<--- beos_readdir() "
 891 +                               "cannot read index node\n"));
 892 +                       return -EBADF;
 893 +
 894 +               }
 895 +
 896 +               bn = (beos_index_node *) (bh->b_data + offset);
 897 +               BEOS_DUMP_INDEX_NODE (bn);
 898 +
 899 +               /*
 900 +                * Is there no directry key in this index node?
 901 +                */
 902 +
 903 +               if (bn->all_key_count + count <= filp->f_pos) {
 904 +
 905 +                       /*
 906 +                        * Not exist
 907 +                        */
 908 +
 909 +                       BEOS_OUTPUT (("key not exist. next...\n"));
 910 +                       count += bn->all_key_count;
 911 +                       brelse (bh);
 912 +                       continue;
 913 +
 914 +               }
 915 +
 916 +               k = filp->f_pos - count;
 917 +
 918 +               /*
 919 +                * search key
 920 +                */
 921 +
 922 +               if (!beos_get_key_from_index_node (bn, &k,
 923 +                       sb->u.beos_sb.mount_opts.beos_type, tmpname, &len,
 924 +                       &value)) {
 925 +
 926 +                       putname (tmpname);
 927 +                       brelse (bh);
 928 +
 929 +                       return -EBADF;
 930 +               }
 931 +
 932 +               /*
 933 +                * Convert UTF-8 to nls charset
 934 +                */
 935 +
 936 +               if (!beos_utf2nls (tmpname, len, &tmpname2, &len_dist, sb)) {
 937 +                       putname (tmpname);
 938 +                       brelse (bh);
 939 +
 940 +                       return -ENOMEM;
 941 +               }
 942 +               error = filldir (dirent, tmpname2, len_dist, filp->f_pos,
 943 +                       (ino_t) value);
 944 +               putname (tmpname2);
 945 +
 946 +               if (error)
 947 +                       filp->f_pos = 0;
 948 +               else
 949 +                       filp->f_pos++;
 950 +
 951 +               brelse (bh);
 952 +
 953 +               goto finish;
 954 +       }
 955 +
 956 +       filp->f_pos = 0;
 957 +finish:
 958 +       putname (tmpname);
 959 +
 960 +       BEOS_OUTPUT (("<--- beos_readdir() filp->f_pos %d\n",
 961 +               filp->f_pos));
 962 +
 963 +       return 0;
 964 +}
 965 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/file.c linux-2.2.18-pre2-beos/fs/beos/file.c
 966 --- linux-2.2.18-pre2-clean/fs/beos/file.c      Wed Dec 31 18:00:00 1969
 967 +++ linux-2.2.18-pre2-beos/fs/beos/file.c       Thu Aug 24 10:45:24 2000
 968 @@ -0,0 +1,452 @@
 969 +/*
 970 + *  linux/fs/beos/file.c
 971 + *
 972 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
 973 + *
 974 + *  from
 975 + *
 976 + *  linux/fs/minix/file.c
 977 + *
 978 + *  Copyright (C) 1991, 1992  Linus Torvalds
 979 + */
 980 +
 981 +#include <asm/uaccess.h>
 982 +#include <asm/system.h>
 983 +
 984 +#include <linux/errno.h>
 985 +#include <linux/fs.h>
 986 +#include <linux/beos_fs.h>
 987 +#include <linux/fcntl.h>
 988 +#include <linux/sched.h>
 989 +#include <linux/stat.h>
 990 +#include <linux/locks.h>
 991 +#include <linux/mm.h>
 992 +#include <linux/pagemap.h>
 993 +
 994 +
 995 +ssize_t beos_file_read (struct file *, char *,  size_t, loff_t *);
 996 +static beos_inode_addr beos_startpos_from_ds (struct super_block *,
 997 +       beos_data_stream *, off_t);
 998 +static int beos_read_indirect_block (struct super_block *, const beos_inode_addr,
 999 +       const int, beos_inode_addr *);
1000 +static int beos_read_double_indirect_block (struct super_block *,
1001 +       const beos_inode_addr, const int, beos_inode_addr *);
1002 +static ssize_t beos_file_write (struct file *, const char *, size_t, loff_t *);
1003 +
1004 +
1005 +static struct file_operations beos_file_ops =
1006 +{
1007 +       NULL,                   /* lseek */
1008 +       beos_file_read,
1009 +#ifdef CONFIG_BEOS_FS_RW
1010 +       beos_file_write,
1011 +#else
1012 +       NULL,
1013 +#endif
1014 +       NULL,                   /* readdir - bad */
1015 +       NULL,                   /* poll - default */
1016 +       NULL,                   /* ioctl - default */
1017 +       generic_file_mmap,
1018 +       NULL,
1019 +       NULL,                   /* flush */
1020 +       NULL,                   /* release */
1021 +       file_fsync,
1022 +};
1023 +
1024 +struct inode_operations beos_file_inode_operations =
1025 +{
1026 +       &beos_file_ops,         /* default file operations */
1027 +       NULL,                                   /* create */
1028 +       NULL,                                   /* lookup */
1029 +       NULL,                                   /* link */
1030 +       NULL,                                   /* unlink */
1031 +       NULL,                                   /* symlink */
1032 +       NULL,                                   /* mkdir */
1033 +       NULL,                                   /* rmdir */
1034 +       NULL,                                   /* mknod */
1035 +       NULL,                                   /* rename */
1036 +       NULL,                                   /* readlink */
1037 +       NULL,                                   /* follow_link */
1038 +       generic_readpage,       /* readpage */
1039 +       NULL,                                   /* writepage */
1040 +       &beos_bmap,             /* bmap */
1041 +       NULL,                                   /* truncate */
1042 +       NULL,                                   /* permission */
1043 +       NULL                                    /* smap */
1044 +};
1045 +
1046 +
1047 +ssize_t beos_file_read(struct file *filp, char *buf,  size_t count, loff_t *ppos)
1048 +{
1049 +       struct inode *       inode = filp->f_dentry->d_inode;
1050 +       struct super_block * sb = inode->i_sb;
1051 +       beos_data_stream *    ds = &inode->u.beos_i.i_data.ds;
1052 +       beos_inode_addr       iaddr;
1053 +       beos_inode_addr       iaddr2;
1054 +       off_t                pos = *ppos;
1055 +       off_t                sum = 0;
1056 +       int                  i;
1057 +       int                  j;
1058 +       off_t                read_count;
1059 +       off_t                offset;
1060 +
1061 +       BEOS_OUTPUT (("---> beos_file_read() "
1062 +               "inode %lu count %lu ppos %Lu\n",
1063 +               inode->i_ino, (__u32) count, *ppos));
1064 +
1065 +       /*
1066 +        * Get start position
1067 +        */
1068 +
1069 +       for (i = 0; ;) {
1070 +               iaddr = beos_read_data_stream (sb, ds, &i);
1071 +               if (BEOS_IS_EMPTY_IADDR(&iaddr)) {
1072 +                       BEOS_OUTPUT ((" end data_stream\n"));
1073 +                       break;
1074 +               }
1075 +
1076 +               if ((pos >= sum)
1077 +                       && (pos < sum + iaddr.len * sb->u.beos_sb.block_size)) {
1078 +
1079 +                       iaddr.start += (pos - sum) / sb->u.beos_sb.block_size;
1080 +                       iaddr.len -= (pos - sum) / sb->u.beos_sb.block_size;
1081 +                       break;
1082 +               }
1083 +               sum += iaddr.len * sb->u.beos_sb.block_size;
1084 +       }
1085 +
1086 +       read_count = 0;
1087 +       offset = (pos - sum) % sb->u.beos_sb.block_size;
1088 +       iaddr2 = iaddr;
1089 +
1090 +       count = inode->i_size > pos + count ? count : inode->i_size - pos;
1091 +
1092 +       for ( j = 0; j < iaddr.len; j++) {
1093 +
1094 +               struct buffer_head * bh;
1095 +
1096 +               bh = beos_bread2 (sb, iaddr2);
1097 +               if (!bh)
1098 +                       return -EBADF;
1099 +
1100 +               BEOS_OUTPUT ((" read_count %Ld offset %Ld\n",
1101 +                       read_count, offset));
1102 +
1103 +               if (count > sb->u.beos_sb.block_size) {
1104 +
1105 +                       memcpy (buf + read_count, bh->b_data + offset,
1106 +                               sb->u.beos_sb.block_size - offset);
1107 +
1108 +                       *ppos += sb->u.beos_sb.block_size - offset;
1109 +                       count -= sb->u.beos_sb.block_size - offset;
1110 +                       read_count += sb->u.beos_sb.block_size - offset;
1111 +                       offset = 0;
1112 +
1113 +                       iaddr2.start += 1;
1114 +
1115 +                       brelse (bh);
1116 +
1117 +               } else {
1118 +
1119 +                       memcpy (buf + read_count, bh->b_data + offset, count);
1120 +
1121 +                       *ppos += count;
1122 +                       read_count += count;
1123 +
1124 +                       brelse (bh);
1125 +                       break;
1126 +               }
1127 +       }
1128 +
1129 +       ppos += read_count;
1130 +
1131 +       BEOS_OUTPUT (("<--- beos_file_read() "
1132 +               "return value %d, ppos %Ld\n", read_count, *ppos));
1133 +
1134 +       return read_count;
1135 +}
1136 +
1137 +/*
1138 + * Read indirect block
1139 + */
1140 +
1141 +static int beos_read_indirect_block (struct super_block * sb,
1142 +       const beos_inode_addr indirect, const int pos,
1143 +       beos_inode_addr * iaddr)
1144 +{
1145 +       beos_inode_addr *     array;
1146 +       struct buffer_head * bh;
1147 +       beos_inode_addr       addr = indirect;
1148 +       int                  p = pos;
1149 +
1150 +       BEOS_OUTPUT (("---> beos_read_indirect_block()\n"));
1151 +
1152 +       /*
1153 +        * explore nessealy block
1154 +        */
1155 +
1156 +       addr.start += p / BEOS_BLOCK_PER_INODE(sb);
1157 +       addr.len -= p / BEOS_BLOCK_PER_INODE(sb);
1158 +
1159 +       if (addr.len < 1) {
1160 +               goto error;
1161 +       }
1162 +
1163 +       p = p % BEOS_BLOCK_PER_INODE(sb);
1164 +
1165 +       bh = beos_bread2 (sb, addr);
1166 +       if (!bh) {
1167 +               goto error;
1168 +       }
1169 +
1170 +       array = (beos_inode_addr *) bh->b_data;
1171 +
1172 +       /*
1173 +        * Is this block inode address??
1174 +        */
1175 +
1176 +       if (!BEOS_IS_EMPTY_IADDR(&array[p % BEOS_BLOCK_PER_INODE(sb)])) {
1177 +               *iaddr = array[p % BEOS_BLOCK_PER_INODE(sb)];
1178 +       } else {
1179 +               brelse (bh);
1180 +               goto error;
1181 +       }
1182 +
1183 +       brelse (bh);
1184 +
1185 +       BEOS_OUTPUT (("<--- beos_read_indirect_block()\n"));
1186 +
1187 +       return 0;
1188 +
1189 +error:
1190 +       printk ("BEOS: cannot read indirect block\n");
1191 +       return -EBADF;
1192 +}
1193 +
1194 +/*
1195 + * beos_read_double_indirect_block
1196 + *
1197 + * description:
1198 + *  Read double-indirect block
1199 + *
1200 + * parameter:
1201 + *  sb              ... super block
1202 + *  double_indirect ... inode address of double-indirect block
1203 + *  pos             ... position of double-indirect block
1204 + *                       (*pos - max_direct_block - max_indirect_block)
1205 + *
1206 + * return value:
1207 + *  0 ... sucess
1208 + */
1209 +
1210 +static int beos_read_double_indirect_block (struct super_block * sb,
1211 +        const beos_inode_addr double_indirect, const int pos,
1212 +       beos_inode_addr * iaddr)
1213 +{
1214 +        struct buffer_head *  bh_indirect;
1215 +        int                   p = pos;
1216 +        beos_inode_addr *      indirects;
1217 +       beos_inode_addr        addr = double_indirect;
1218 +       int                   i;
1219 +
1220 +       BEOS_OUTPUT (("---> beos_read_double_indirect_block() \n"));
1221 +
1222 +        while (addr.len) {
1223 +                bh_indirect = beos_bread2 (sb, addr);
1224 +
1225 +                if (!bh_indirect) {
1226 +                        BEOS_OUTPUT (("cannot read double-indirect block "
1227 +                                "[%lu, %u, %u]\n",
1228 +                                double_indirect.allocation_group,
1229 +                                double_indirect.start, double_indirect.len));
1230 +                        return -EBADF;
1231 +                }
1232 +
1233 +                addr.start++;
1234 +                addr.len--;
1235 +
1236 +                indirects = (beos_inode_addr *) bh_indirect->b_data;
1237 +
1238 +                for (i = 0; i < BEOS_BLOCK_PER_INODE(sb); i++) {
1239 +
1240 +                        if (p < indirects[i].len * BEOS_BLOCK_PER_INODE(sb)) {
1241 +
1242 +                                /*
1243 +                                 * find block!
1244 +                                 */
1245 +
1246 +                               int err;
1247 +
1248 +                               err = beos_read_indirect_block (sb,
1249 +                                       indirects[i], p, iaddr);
1250 +                               brelse (bh_indirect);
1251 +
1252 +                               return err;
1253 +                        }
1254 +
1255 +                        p -= indirects[i].len * BEOS_BLOCK_PER_INODE(sb);
1256 +                }
1257 +
1258 +                brelse(bh_indirect);
1259 +        }
1260 +
1261 +        /*
1262 +         * cannot find block...
1263 +         */
1264 +
1265 +        BEOS_OUTPUT (("cannot find block...\n"));
1266 +
1267 +        return -EIO;
1268 +}
1269 +
1270 +
1271 +beos_inode_addr beos_read_data_stream (struct super_block * sb,
1272 +       beos_data_stream * ds, int * pos)
1273 +{
1274 +        beos_inode_addr       iaddr = {0, 0, 0};
1275 +
1276 +       BEOS_OUTPUT (("---> beos_read_data_stream() "
1277 +               "pos %d\n", *pos));
1278 +
1279 +        if( *pos < 0 )
1280 +                return iaddr;
1281 +
1282 +        if (*pos < ds->max_direct_range) {
1283 +
1284 +               /*
1285 +                * This position is in direct block.
1286 +                */
1287 +
1288 +               BEOS_OUTPUT ((" read in direct block [%lu, %u, %u]\n",
1289 +                       ds->direct[*pos].allocation_group,
1290 +                       ds->direct[*pos].start, ds->direct[*pos].len));
1291 +
1292 +               /*
1293 +                * Is this block inode address??
1294 +                */
1295 +
1296 +                if (!BEOS_IS_EMPTY_IADDR(&ds->direct[*pos])) {
1297 +                       iaddr = ds->direct[(*pos)++];
1298 +               }
1299 +        } else if (*pos < ds->max_indirect_range + ds->max_direct_range) {
1300 +
1301 +               /*
1302 +                * This position is in in-direct block.
1303 +                */
1304 +
1305 +               int  p = *pos - ds->max_direct_range;
1306 +
1307 +               BEOS_OUTPUT ((" read in indirect block [%lu, %u, %u]\n",
1308 +                       ds->indirect.allocation_group, ds->indirect.start,
1309 +                       ds->indirect.len));
1310 +
1311 +               if (!beos_read_indirect_block (sb, ds->indirect, p, &iaddr)) {
1312 +                       (*pos)++;
1313 +               }
1314 +        } else if (*pos < ds->max_double_indirect_range
1315 +               + ds->max_direct_range + ds->max_indirect_range) {
1316 +
1317 +               /*
1318 +                * This position is in double-in-direct block.
1319 +                */
1320 +
1321 +               int  p = *pos - ds->max_direct_range - ds->max_indirect_range;
1322 +
1323 +               BEOS_OUTPUT ((" read in double indirect block\n"));
1324 +
1325 +               if (!beos_read_double_indirect_block (sb, ds->double_indirect,
1326 +                       p, &iaddr)) {
1327 +
1328 +                       (*pos)++;
1329 +               }
1330 +        } else {
1331 +               /*
1332 +                * out of range block
1333 +                */
1334 +       }
1335 +
1336 +       if (BEOS_IS_EMPTY_IADDR(&iaddr))
1337 +               *pos = 0;
1338 +
1339 +        return iaddr;
1340 +}
1341 +
1342 +/*
1343 + * Get inode address of start position form data stream
1344 + */
1345 +
1346 +static beos_inode_addr beos_startpos_from_ds (struct super_block * sb,
1347 +                                       beos_data_stream * ds, off_t pos)
1348 +{
1349 +       beos_inode_addr iaddr;
1350 +       off_t          sum = 0;
1351 +       int            i = 0;
1352 +
1353 +       BEOS_OUTPUT (("---> beos_startpos_from_ds()\n"));
1354 +
1355 +       /*
1356 +        * Get start position
1357 +        */
1358 +
1359 +       while(1) {
1360 +               iaddr = beos_read_data_stream (sb, ds, &i);
1361 +               if (BEOS_IS_EMPTY_IADDR(&iaddr)) {
1362 +                       BEOS_OUTPUT ((" end data_stream\n"));
1363 +                       break;
1364 +               }
1365 +
1366 +               if ((pos >= sum)
1367 +                       && (pos < sum + iaddr.len * sb->u.beos_sb.block_size)) {
1368 +                       iaddr.start += (pos - sum) / sb->u.beos_sb.block_size;
1369 +                       iaddr.len -= (pos - sum) / sb->u.beos_sb.block_size;
1370 +                       break;
1371 +               }
1372 +               sum += iaddr.len * sb->u.beos_sb.block_size;
1373 +       }
1374 +
1375 +       BEOS_OUTPUT (("<--- beos_startpos_from_ds()\n"));
1376 +
1377 +       return iaddr;
1378 +}
1379 +
1380 +#ifdef CONFIG_BEOS_RW
1381 +static ssize_t beos_file_write (struct file * filp, const char * buf,
1382 +                                size_t count, loff_t *ppos)
1383 +{
1384 +       struct inode *       inode = filp->f_dentry->d_inode;
1385 +       struct super_block * sb;
1386 +//     struct buffer_head * bh;
1387 +       beos_data_stream *    ds;
1388 +       beos_inode_addr       iaddr;
1389 +       loff_t               pos;
1390 +       ssize_t              written;
1391 +
1392 +       if (!inode) {
1393 +               return -EINVAL;
1394 +       }
1395 +
1396 +       if (!S_ISREG(inode->i_mode)) {
1397 +               return -EINVAL;
1398 +       }
1399 +
1400 +       sb = inode->i_sb;
1401 +       ds = &inode->u.beos_i.i_data.ds;
1402 +
1403 +       if (filp->f_flags & O_APPEND)
1404 +               pos = inode->i_size;
1405 +       else
1406 +               pos = *ppos;
1407 +
1408 +       iaddr = beos_startpos_from_ds (sb, ds, pos);
1409 +       written = 0;
1410 +
1411 +       if (pos > inode->i_size)
1412 +               inode->i_size = pos;
1413 +
1414 +       inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1415 +       *ppos = pos;
1416 +       mark_inode_dirty(inode);
1417 +
1418 +       return written;
1419 +}
1420 +#endif
1421 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/index.c linux-2.2.18-pre2-beos/fs/beos/index.c
1422 --- linux-2.2.18-pre2-clean/fs/beos/index.c     Wed Dec 31 18:00:00 1969
1423 +++ linux-2.2.18-pre2-beos/fs/beos/index.c      Mon Aug 28 18:20:44 2000
1424 @@ -0,0 +1,321 @@
1425 +/*
1426 + *  linux/beos/fs/index.c
1427 + *
1428 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
1429 + *
1430 + *
1431 + *  Index functions for BEOS.
1432 + */
1433 +
1434 +#include <asm/uaccess.h>
1435 +
1436 +#include <linux/errno.h>
1437 +#include <linux/fs.h>
1438 +#include <linux/sched.h>
1439 +#include <linux/stat.h>
1440 +#include <linux/mm.h>
1441 +#include <linux/slab.h>
1442 +
1443 +
1444 +static void beos_convert_index_entry (int, beos_index_entry *, beos_index_entry *);
1445 +static void beos_convert_index_node (int, beos_index_node *, beos_index_node *);
1446 +
1447 +/*
1448 + * Convert little-edian and big-edian.
1449 + */
1450 +
1451 +static void beos_convert_index_entry (int fstype, beos_index_entry * entry,
1452 +       beos_index_entry * out)
1453 +{
1454 +       switch (fstype)
1455 +       {
1456 +       case BEOS_X86:
1457 +               out->magic = le32_to_cpu(entry->magic);
1458 +               out->node_size = le32_to_cpu(entry->node_size);
1459 +               out->max_number_of_levels =
1460 +                       le32_to_cpu(entry->max_number_of_levels);
1461 +               out->data_type = le32_to_cpu(entry->data_type);
1462 +               out->root_node_pointer =
1463 +                       le64_to_cpu(entry->root_node_pointer);
1464 +               out->free_node_pointer =
1465 +                       le64_to_cpu(entry->free_node_pointer);
1466 +               out->maximum_size = le64_to_cpu(entry->maximum_size);
1467 +               break;
1468 +
1469 +       case BEOS_PPC:
1470 +               out->magic = be32_to_cpu(entry->magic);
1471 +               out->node_size = be32_to_cpu(entry->node_size);
1472 +               out->max_number_of_levels =
1473 +                       be32_to_cpu(entry->max_number_of_levels);
1474 +               out->data_type = be32_to_cpu(entry->data_type);
1475 +               out->root_node_pointer =
1476 +                       be64_to_cpu(entry->root_node_pointer);
1477 +               out->free_node_pointer =
1478 +                       be64_to_cpu(entry->free_node_pointer);
1479 +               out->maximum_size = be64_to_cpu(entry->maximum_size);
1480 +               break;
1481 +       }
1482 +}
1483 +
1484 +
1485 +static void beos_convert_index_node (int fstype, beos_index_node * node,
1486 +       beos_index_node * out)
1487 +{
1488 +       switch (fstype)
1489 +       {
1490 +       case BEOS_X86:
1491 +               out->left = le64_to_cpu (node->left);
1492 +               out->right = le64_to_cpu (node->right);
1493 +               out->overflow = le64_to_cpu (node->overflow);
1494 +               out->all_key_count = le16_to_cpu (node->all_key_count);
1495 +               out->all_key_length = le16_to_cpu (node->all_key_length);
1496 +               break;
1497 +
1498 +       case BEOS_PPC:
1499 +               out->left = be64_to_cpu (node->left);
1500 +               out->right = be64_to_cpu (node->right);
1501 +               out->overflow = be64_to_cpu (node->overflow);
1502 +               out->all_key_count = be16_to_cpu (node->all_key_count);
1503 +               out->all_key_length = be16_to_cpu (node->all_key_length);
1504 +               break;
1505 +       }
1506 +}
1507 +
1508 +
1509 +/*
1510 + * beos_read_index_node
1511 + *
1512 + * description:
1513 + *  read index node from inode.
1514 + *
1515 + * parameter:
1516 + *  inode  ... address of index node
1517 + *  sb     ... super block
1518 + *  flags  ... 0 ... inode is index entry
1519 + *             1 ... inode is index node
1520 + *  offset ... offset into index address
1521 + */
1522 +
1523 +struct buffer_head * beos_read_index_node (beos_inode_addr inode,
1524 +       struct super_block * sb, int flags, beos_off_t * offset)
1525 +{
1526 +       struct buffer_head * bh;
1527 +       beos_inode_addr       iaddr;
1528 +       beos_index_entry *    entry;
1529 +
1530 +       BEOS_OUTPUT (("---> beos_read_index_node() "
1531 +               "index [%lu, %u, %u]\n",
1532 +               inode.allocation_group, inode.start, inode.len));
1533 +
1534 +       if (!flags) {
1535 +
1536 +               /*
1537 +                * read index entry
1538 +                */
1539 +
1540 +               bh = beos_bread2 (sb, inode);
1541 +               if (!bh) {
1542 +                       printk (KERN_ERR "BEOS: cannot read index entry.\n");
1543 +                       return NULL;
1544 +               }
1545 +#ifndef CONFIG_BEOS_CONV
1546 +               entry = (beos_index_entry *) bh->b_data;
1547 +#else
1548 +               entry = (beos_index_entry *) __getname();;
1549 +               if (!entry) {
1550 +                       printk (KERN_ERR "BEOS: cannot allocate memory\n");
1551 +                       return NULL;
1552 +               }
1553 +
1554 +               /*
1555 +                * Convert little-edian and big-edian.
1556 +                */
1557 +
1558 +               beos_convert_index_entry (sb->u.beos_sb.mount_opts.beos_type,
1559 +                       (beos_index_entry *) bh->b_data, entry);
1560 +#endif
1561 +               BEOS_DUMP_INDEX_ENTRY (entry);
1562 +
1563 +               /*
1564 +                * check magic header
1565 +                */
1566 +
1567 +               if (entry->magic != BEOS_INDEX_MAGIC) {
1568 +
1569 +                       /*
1570 +                        * bad magic header
1571 +                        */
1572 +
1573 +                       printk (KERN_ERR "BEOS: "
1574 +                               "magic header of index entry is bad value.\n");
1575 +#ifdef CONFIG_BEOS_CONV
1576 +                       putname (entry);
1577 +#endif
1578 +                       brelse(bh);
1579 +
1580 +                       return NULL;
1581 +               }
1582 +
1583 +               /*
1584 +                * set index entry postion
1585 +                */
1586 +
1587 +               *offset = 0;
1588 +               iaddr = inode;
1589 +               if (entry->node_size < sb->u.beos_sb.block_size) {
1590 +
1591 +                       /*
1592 +                        * exist index node into index entry's block
1593 +                        */
1594 +
1595 +                       *offset = entry->node_size;
1596 +
1597 +               } else {
1598 +
1599 +                       iaddr.start += entry->node_size / sb->u.beos_sb.block_size;
1600 +                       iaddr.len -= entry->node_size / sb->u.beos_sb.block_size;
1601 +                       *offset = entry->node_size % sb->u.beos_sb.block_size;
1602 +
1603 +               }
1604 +
1605 +#ifdef CONFIG_BEOS_CONV
1606 +               putname (entry);
1607 +#endif
1608 +               brelse(bh);
1609 +
1610 +       } else {
1611 +               BEOS_OUTPUT ((" skip index node\n"));
1612 +               iaddr = inode;
1613 +       }
1614 +
1615 +       BEOS_OUTPUT ((" inode of index node\n"));
1616 +       BEOS_DUMP_INODE_ADDR (iaddr);
1617 +
1618 +       bh = beos_bread2 (sb, iaddr);
1619 +       if (!bh) {
1620 +               return NULL;
1621 +       }
1622 +
1623 +       BEOS_OUTPUT (("<--- beos_read_index_node() offset = %016x\n", *offset));
1624 +
1625 +       return bh;
1626 +}
1627 +
1628 +
1629 +/*
1630 + * beos_get_key_from_index_node
1631 + *
1632 + * description:
1633 + *  Get key form index node
1634 + *
1635 + *  parameter:
1636 + *   bn     ... index node structure
1637 + *   pos    ... key position
1638 + *   fstype ... filesystem type
1639 + *   name   ... keyname return
1640 + *   len    ... length of keyname return.
1641 + *   iaddr  ... key valude return.
1642 + */
1643 +
1644 +char * beos_get_key_from_index_node (beos_index_node * node, int *pos, int fstype,
1645 +       char * name, int * len, beos_off_t * iaddr)
1646 +{
1647 +       char *           key;
1648 +       __u16 *          key_array;
1649 +       beos_off_t *      key_value;
1650 +       int              key_offset;
1651 +       char *           namep = NULL;
1652 +       beos_index_node * bn;
1653 +
1654 +       BEOS_OUTPUT (("---> beos_get_key_from_index_node() "
1655 +               "pos %d\n", *pos));
1656 +
1657 +       /*
1658 +        * Convert little-edian and big-edian.
1659 +        */
1660 +#ifndef CONFIG_BEOS_CONV
1661 +       bn = node;
1662 +#else
1663 +       bn = (beos_index_node *) __getname();
1664 +       beos_convert_index_node (fstype, node, bn);
1665 +#endif
1666 +
1667 +       if (*pos < 0 || bn->all_key_count <= *pos) {
1668 +               *pos = -1;
1669 +               return NULL;
1670 +       }
1671 +
1672 +       /*
1673 +        * Only key_array, byte is 8byte...
1674 +        */
1675 +
1676 +       key = (char*) node + sizeof(beos_index_node);
1677 +       key_offset = (bn->all_key_length + sizeof(beos_index_node)) % 8;
1678 +       key_array = (__u16 *) (key + bn->all_key_length
1679 +               + (!key_offset ? 0 : 8 - key_offset));
1680 +       key_value = (beos_inode_addr *) (((char *) key_array) + sizeof(__u16)
1681 +               * bn->all_key_count);
1682 +#ifdef BEOS_DEBUG
1683 +       {
1684 +               int j;
1685 +               char key_test[4096];
1686 +
1687 +               memcpy (key_test, key, bn->all_key_length);
1688 +               key_test[bn->all_key_length] = '\0';
1689 +
1690 +               BEOS_OUTPUT ((" key %08x key_array %08x key_value %08x\n",
1691 +                       (long) key, (long) key_array, (long) key_value));
1692 +
1693 +               BEOS_OUTPUT ((" key content %s\n", key_test));
1694 +
1695 +               for (j = 0; j < *pos; j++) {
1696 +                       BEOS_OUTPUT ((" key_array[%d] = %Ld  ",
1697 +                               j, key_array[j]));
1698 +                       BEOS_OUTPUT (("key_value[%d] = %Ld\n", j, key_value[j]));
1699 +               }
1700 +       }
1701 +#endif
1702 +       switch (fstype)
1703 +       {
1704 +       case BEOS_X86:
1705 +               if (*pos == 0) {
1706 +                       namep = key;
1707 +                       *len = le16_to_cpu(key_array[*pos]);
1708 +               } else {
1709 +                       namep = key + le16_to_cpu(key_array[*pos - 1]);
1710 +                       *len = le16_to_cpu(key_array[*pos])
1711 +                               - le16_to_cpu(key_array[*pos - 1]);
1712 +               }
1713 +               *iaddr = le64_to_cpu(key_value[*pos]);
1714 +               break;
1715 +
1716 +       case BEOS_PPC:
1717 +               if (*pos == 0) {
1718 +                       namep = key;
1719 +                       *len = be16_to_cpu(key_array[*pos]);
1720 +               } else {
1721 +                       namep = key + be16_to_cpu(key_array[*pos - 1]);
1722 +                       *len = be16_to_cpu(key_array[*pos])
1723 +                               - be16_to_cpu(key_array[*pos - 1]);
1724 +               }
1725 +               *iaddr = be64_to_cpu(key_value[*pos]);
1726 +               break;
1727 +       }
1728 +
1729 +       /*
1730 +        * copy from namep to name
1731 +        */
1732 +
1733 +       memcpy (name, namep, *len);
1734 +       name[*len] = '\0';
1735 +       (*pos)++;
1736 +
1737 +#ifdef CONFIG_BEOS_CONV
1738 +       putname (bn);
1739 +#endif
1740 +
1741 +       BEOS_OUTPUT (("<--- beos_get_key_from_index_node() "
1742 +               "result key [%s], value %Lu\n", name, *iaddr));
1743 +
1744 +       return name;
1745 +}
1746 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/inode.c linux-2.2.18-pre2-beos/fs/beos/inode.c
1747 --- linux-2.2.18-pre2-clean/fs/beos/inode.c     Wed Dec 31 18:00:00 1969
1748 +++ linux-2.2.18-pre2-beos/fs/beos/inode.c      Sun Aug 27 21:36:39 2000
1749 @@ -0,0 +1,464 @@
1750 +/*
1751 + *  linux/fs/beos/inode.c
1752 + *
1753 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
1754 + *
1755 + *  from
1756 + *
1757 + *  linux/fs/minix/inode.c
1758 + *
1759 + *  Copyright (C) 1991, 1992  Linus Torvalds
1760 + */
1761 +
1762 +#include <asm/uaccess.h>
1763 +#include <asm/system.h>
1764 +
1765 +#include <linux/errno.h>
1766 +#include <linux/fs.h>
1767 +//#include <linux/beos_fs.h>
1768 +#include <linux/beos_fs_sb.h>
1769 +#include <linux/beos_fs_i.h>
1770 +#include <linux/sched.h>
1771 +#include <linux/stat.h>
1772 +#include <linux/string.h>
1773 +#include <linux/locks.h>
1774 +#include <linux/mm.h>
1775 +
1776 +
1777 +//static int beos_update_inode(struct inode *, int);
1778 +
1779 +/*
1780 + * return blocknumber
1781 + */
1782 +
1783 +int beos_bmap (struct inode * inode, int block)
1784 +{
1785 +       struct beos_sb_info    bs = inode->i_sb->u.beos_sb;
1786 +       struct beos_inode_info bi = inode->u.beos_i;
1787 +
1788 +       BEOS_OUTPUT (("---> Enter beos_bmap\n"));
1789 +
1790 +       BEOS_OUTPUT (("<--- Enter beos_bmap\n"));
1791 +
1792 +       return  (bi.i_inode_num.allocation_group << bs.ag_shift)
1793 +               + bi.i_inode_num.start;
1794 +}
1795 +
1796 +
1797 +/*
1798 + * beos_bread function
1799 + *
1800 + *  get buffer_header for inode.
1801 + */
1802 +
1803 +struct buffer_head * beos_bread (struct inode * inode)
1804 +{
1805 +       beos_off_t             offset;
1806 +       struct super_block *  sb = inode->i_sb;
1807 +       dev_t                 dev = sb->s_dev;
1808 +
1809 +       BEOS_OUTPUT (("---> Enter beos_read "
1810 +               "[%lu, %u, %u]\n",
1811 +               inode->u.beos_i.i_inode_num.allocation_group,
1812 +               inode->u.beos_i.i_inode_num.start,
1813 +               inode->u.beos_i.i_inode_num.len));
1814 +
1815 +       offset = (inode->u.beos_i.i_inode_num.allocation_group
1816 +               << sb->u.beos_sb.ag_shift) + inode->u.beos_i.i_inode_num.start;
1817 +
1818 +       BEOS_OUTPUT (("<--- Enter beos_read\n"));
1819 +
1820 +       return bread (dev, offset, sb->s_blocksize);
1821 +}
1822 +
1823 +
1824 +struct buffer_head * beos_bread2 (struct super_block * sb, beos_inode_addr inode)
1825 +{
1826 +       dev_t     dev = sb->s_dev;
1827 +       beos_off_t offset;
1828 +
1829 +       BEOS_OUTPUT (("---> Enter beos_read2 "
1830 +               "[%lu, %u, %u]\n",
1831 +               inode.allocation_group, inode.start, inode.len));
1832 +
1833 +       offset = (inode.allocation_group << sb->u.beos_sb.ag_shift)
1834 +               + inode.start;
1835 +
1836 +       BEOS_OUTPUT (("<--- Enter beos_read2\n"));
1837 +
1838 +       return bread (dev, offset, sb->s_blocksize);
1839 +}
1840 +
1841 +
1842 +/*
1843 + * Convert little-endian and big-endian
1844 + */
1845 +
1846 +void beos_convert_inodeaddr (int fstype, beos_inode_addr * iaddr,
1847 +       beos_inode_addr * out)
1848 +{
1849 +       switch (fstype)
1850 +       {
1851 +       case BEOS_X86:
1852 +               out->allocation_group = le32_to_cpu(iaddr->allocation_group);
1853 +               out->start = le16_to_cpu(iaddr->start);
1854 +               out->len = le16_to_cpu(iaddr->len);
1855 +               break;
1856 +
1857 +       case BEOS_PPC:
1858 +               out->allocation_group = be32_to_cpu(iaddr->allocation_group);
1859 +               out->start = be16_to_cpu(iaddr->start);
1860 +               out->len = be16_to_cpu(iaddr->len);
1861 +               break;
1862 +       }
1863 +}
1864 +
1865 +static void beos_convert_inode (int fstype, beos_inode *inode, beos_inode * out)
1866 +{
1867 +       int i;
1868 +
1869 +       /*
1870 +        * Convert data stream.
1871 +        */
1872 +
1873 +       switch (fstype)
1874 +       {
1875 +       case BEOS_X86:
1876 +               out->magic1 = le32_to_cpu(inode->magic1);
1877 +               beos_convert_inodeaddr (fstype, &inode->inode_num,
1878 +                       &out->inode_num);
1879 +               out->uid = le32_to_cpu(inode->uid);
1880 +               out->gid = le32_to_cpu(inode->gid);
1881 +               out->mode = le32_to_cpu(inode->mode);
1882 +               out->flags = le32_to_cpu(inode->flags);
1883 +               out->create_time = le64_to_cpu(inode->create_time);
1884 +               out->last_modified_time =
1885 +                       le64_to_cpu(inode->last_modified_time);
1886 +               inode->type = le32_to_cpu(inode->type);
1887 +               beos_convert_inodeaddr (fstype, &inode->parent, &out->parent);
1888 +               beos_convert_inodeaddr (fstype, &inode->attributes, &out->attributes);
1889 +               out->inode_size = le32_to_cpu(inode->inode_size);
1890 +
1891 +               if (!S_ISLNK((umode_t) out->mode)) {
1892 +                       /*
1893 +                        * Convert data stream.
1894 +                        */
1895 +
1896 +                       for ( i = 0; i < BEOS_NUM_DIRECT_BLOCKS; i++) {
1897 +                               beos_convert_inodeaddr (fstype,
1898 +                                       &inode->data.datastream.direct[i],
1899 +                                       &out->data.datastream.direct[i]);
1900 +                       }
1901 +                       beos_convert_inodeaddr (fstype,
1902 +                               &inode->data.datastream.indirect,
1903 +                               &out->data.datastream.indirect);
1904 +                       beos_convert_inodeaddr (fstype,
1905 +                               &inode->data.datastream.double_indirect,
1906 +                               &out->data.datastream.double_indirect);
1907 +
1908 +                       out->data.datastream.max_direct_range =
1909 +                               le64_to_cpu(inode->data.datastream.max_direct_range);
1910 +                       out->data.datastream.max_indirect_range =
1911 +                               le64_to_cpu(inode->data.datastream.max_indirect_range);
1912 +                       out->data.datastream.max_double_indirect_range =
1913 +                               le64_to_cpu(inode->data.datastream.max_double_indirect_range);
1914 +                       out->data.datastream.size =
1915 +                               le64_to_cpu(inode->data.datastream.size);
1916 +               }
1917 +               break;
1918 +
1919 +       case BEOS_PPC:
1920 +               out->magic1 = be32_to_cpu(inode->magic1);
1921 +               beos_convert_inodeaddr (fstype, &inode->inode_num, &out->inode_num);
1922 +               out->uid = be32_to_cpu(inode->uid);
1923 +               out->gid = be32_to_cpu(inode->gid);
1924 +               out->mode = be32_to_cpu(inode->mode);
1925 +               out->flags = be32_to_cpu(inode->flags);
1926 +               out->create_time = be64_to_cpu(inode->create_time);
1927 +               out->last_modified_time =
1928 +                       be64_to_cpu(inode->last_modified_time);
1929 +               out->type = be32_to_cpu(inode->type);
1930 +               beos_convert_inodeaddr (fstype, &inode->parent, &out->parent);
1931 +               beos_convert_inodeaddr (fstype, &inode->attributes, &out->attributes);
1932 +               out->inode_size = be32_to_cpu(inode->inode_size);
1933 +
1934 +               if (!S_ISLNK((umode_t) out->mode)) {
1935 +
1936 +                       /*
1937 +                        * Convert data stream.
1938 +                        */
1939 +
1940 +                       for ( i = 0; i < BEOS_NUM_DIRECT_BLOCKS; i++) {
1941 +                               beos_convert_inodeaddr (fstype,
1942 +                                       &inode->data.datastream.direct[i],
1943 +                                       &out->data.datastream.direct[i]);
1944 +                       }
1945 +                       beos_convert_inodeaddr (fstype,
1946 +                               &inode->data.datastream.indirect,
1947 +                               &out->data.datastream.indirect);
1948 +                       beos_convert_inodeaddr (fstype,
1949 +                               &inode->data.datastream.double_indirect,
1950 +                               &out->data.datastream.double_indirect);
1951 +
1952 +                       out->data.datastream.max_direct_range =
1953 +                               be64_to_cpu(inode->data.datastream.max_direct_range);
1954 +                       out->data.datastream.max_indirect_range =
1955 +                               be64_to_cpu(inode->data.datastream.max_indirect_range);
1956 +                       out->data.datastream.max_double_indirect_range =
1957 +                               be64_to_cpu(inode->data.datastream.max_double_indirect_range);
1958 +                       out->data.datastream.size =
1959 +                               be64_to_cpu(inode->data.datastream.size);
1960 +               }
1961 +               break;
1962 +       }
1963 +}
1964 +
1965 +
1966 +void beos_read_inode (struct inode * inode)
1967 +{
1968 +       struct buffer_head * bh = NULL;
1969 +       beos_inode *          raw_inode = NULL;
1970 +       beos_inode *          disk_inode;
1971 +
1972 +       int event = 0;
1973 +
1974 +       BEOS_OUTPUT (("---> beos_read_inode() "
1975 +               "inode = %lu[%lu, %u, %u]\n",
1976 +               inode->i_ino,
1977 +               inode->u.beos_i.i_inode_num.allocation_group,
1978 +               inode->u.beos_i.i_inode_num.start,
1979 +               inode->u.beos_i.i_inode_num.len));
1980 +
1981 +       /*
1982 +        * convert from vfs's inode number to beos's inode number
1983 +        */
1984 +
1985 +       if (inode->i_ino != BEOS_INODE2INO(inode))
1986 +       {
1987 +               inode->u.beos_i.i_inode_num.allocation_group =
1988 +                       inode->i_ino >> inode->i_sb->u.beos_sb.ag_shift;
1989 +               inode->u.beos_i.i_inode_num.start = inode->i_ino
1990 +                               & ((2 << inode->i_sb->u.beos_sb.ag_shift) - 1);
1991 +               inode->u.beos_i.i_inode_num.len = 1; /* dummy */
1992 +
1993 +               BEOS_OUTPUT (("  real inode number [%lu, %u, %u]\n",
1994 +                       inode->u.beos_i.i_inode_num.allocation_group,
1995 +                       inode->u.beos_i.i_inode_num.start,
1996 +                       inode->u.beos_i.i_inode_num.len));
1997 +       }
1998 +
1999 +       bh = beos_bread (inode);
2000 +       if (!bh) {
2001 +               printk (KERN_ERR "BEOS: unable to read inode block - inode = %lu",
2002 +                       inode->i_ino);
2003 +               goto bad_inode;
2004 +       }
2005 +
2006 +       disk_inode = (beos_inode *) bh->b_data;
2007 +
2008 +       /*
2009 +        * Convert little-endian or big-endian from beos type.
2010 +        */
2011 +#ifdef CONFIG_BEOS_CONV
2012 +       raw_inode = (beos_inode *) __getname();
2013 +       if (!raw_inode) {
2014 +               printk (KERN_ERR "BEOS: not allocate memory - inode = %lu",
2015 +                       inode->i_ino);
2016 +               goto bad_inode;
2017 +       }
2018 +       beos_convert_inode (inode->i_sb->u.beos_sb.mount_opts.beos_type,
2019 +               disk_inode, raw_inode);
2020 +#else
2021 +       raw_inode = disk_inode;
2022 +#endif
2023 +
2024 +       BEOS_DUMP_INODE (raw_inode);
2025 +
2026 +       /*
2027 +        * inode is current?
2028 +        */
2029 +       if (raw_inode->magic1 != BEOS_INODE_MAGIC1) {
2030 +               printk (KERN_ERR
2031 +                       "BEOS: this inode is bad magic header - inode = %lu\n",
2032 +                       inode->i_ino);
2033 +               goto bad_inode;
2034 +       }
2035 +#if 0
2036 +       if (raw_inode->inode_num != inode->u.beos_i.i_inode_num) {
2037 +               printk ("BEOS: huum... there is no inode.\n");
2038 +               goto bad_inode;
2039 +       }
2040 +#endif
2041 +
2042 +       /*
2043 +        * check flag
2044 +        */
2045 +
2046 +       if (!(raw_inode->flags & BEOS_INODE_IN_USE)) {
2047 +               printk (KERN_ERR "BEOS: inode is not used.\n");
2048 +               goto bad_inode;
2049 +       }
2050 +
2051 +       inode->i_mode = (umode_t) raw_inode->mode;
2052 +
2053 +       /*
2054 +        * set uid and gid.  But since current BeOS is single user OS, so
2055 +        * you can change by "uid" or "gid" options.
2056 +        */
2057 +
2058 +       inode->i_uid = inode->i_sb->u.beos_sb.mount_opts.uid ?
2059 +               inode->i_sb->u.beos_sb.mount_opts.uid : (uid_t) raw_inode->uid;
2060 +       inode->i_gid = inode->i_sb->u.beos_sb.mount_opts.gid ?
2061 +               inode->i_sb->u.beos_sb.mount_opts.gid : (gid_t) raw_inode->gid;
2062 +
2063 +       inode->i_nlink = 1;
2064 +
2065 +       /*
2066 +        * BEOS don't have access time.  So use last modified time.
2067 +        */
2068 +
2069 +       inode->i_atime = (time_t) (raw_inode->last_modified_time >> 16);
2070 +
2071 +       /*
2072 +        * BEOS's time is 64 bits, but current VFS is 32 bits...
2073 +        */
2074 +
2075 +       inode->i_ctime = (time_t) (raw_inode->create_time >> 16);
2076 +       inode->i_mtime = (time_t) (raw_inode->last_modified_time >> 16);
2077 +
2078 +       inode->i_blksize = raw_inode->inode_size;
2079 +
2080 +       inode->i_blocks = raw_inode->inode_size / inode->i_sb->s_blocksize;
2081 +       inode->i_version = ++event;
2082 +       inode->u.beos_i.i_inode_num = (beos_inode_addr) raw_inode->inode_num;
2083 +       inode->u.beos_i.i_mode = raw_inode->mode;
2084 +       inode->u.beos_i.i_flags = raw_inode->flags;
2085 +       inode->u.beos_i.i_create_time = raw_inode->create_time;
2086 +       inode->u.beos_i.i_last_modified_time = raw_inode->last_modified_time;
2087 +
2088 +       inode->u.beos_i.i_parent = (beos_inode_addr) raw_inode->parent;
2089 +       inode->u.beos_i.i_attribute = (beos_inode_addr) raw_inode->attributes;
2090 +
2091 +       /*
2092 +        * Symbolic link have no data stream.
2093 +        * This position is original filename.
2094 +        */
2095 +
2096 +       if (!S_ISLNK(inode->i_mode)) {
2097 +               inode->i_size = raw_inode->data.datastream.size;
2098 +               inode->u.beos_i.i_data.ds = raw_inode->data.datastream;
2099 +       } else {
2100 +               inode->i_size = 0;
2101 +               memcpy (inode->u.beos_i.i_data.symlink, disk_inode->data.symlink,
2102 +                       BEOS_SYMLINK_LEN);
2103 +       }
2104 +
2105 +       if (S_ISREG(inode->i_mode))
2106 +               inode->i_op = &beos_file_inode_operations;
2107 +       else if (S_ISDIR(inode->i_mode))
2108 +               inode->i_op = &beos_dir_inode_operations;
2109 +       else if (S_ISLNK(inode->i_mode))
2110 +               inode->i_op = &beos_symlink_inode_operations;
2111 +       else if (S_ISCHR(inode->i_mode))
2112 +               inode->i_op = &chrdev_inode_operations;
2113 +       else if (S_ISBLK(inode->i_mode))
2114 +               inode->i_op = &blkdev_inode_operations;
2115 +       else if (S_ISFIFO(inode->i_mode))
2116 +               init_fifo(inode);
2117 +
2118 +#ifdef CONFIG_BEOS_CONV
2119 +       putname (raw_inode);
2120 +#endif
2121 +       brelse(bh);
2122 +
2123 +       return;
2124 +
2125 +bad_inode:
2126 +       make_bad_inode(inode);
2127 +#ifdef CONFIG_BEOS_CONV
2128 +       if (raw_inode) {
2129 +               putname (raw_inode);
2130 +       }
2131 +#endif
2132 +       if (bh) {
2133 +               brelse(bh);
2134 +       }
2135 +
2136 +       return;
2137 +}
2138 +
2139 +#ifdef CONFIG_BEOS_RW
2140 +static int beos_update_inode(struct inode * inode, int do_sync)
2141 +{
2142 +       struct buffer_head *  bh;
2143 +       beos_inode *           raw_inode;
2144 +       int                   err = 0;
2145 +
2146 +       bh = beos_bread (inode);
2147 +       if (!bh) {
2148 +               printk(KERN_ERR "BEOS: "
2149 +                       "bad inode number on dev %s: %ld is out of range\n",
2150 +                       bdevname(inode->i_dev), inode->i_ino);
2151 +               return -EIO;
2152 +       }
2153 +
2154 +       raw_inode = (beos_inode *) bh->b_data;
2155 +
2156 +       /*
2157 +        * fill raw_inode
2158 +        */
2159 +
2160 +       raw_inode->magic1 = BEOS_INODE_MAGIC1;
2161 +       raw_inode->inode_num = !IS_EMPTY_IADDR(&inode->u.beos_i.i_inode_num)
2162 +               ? inode->u.beos_i.i_inode_num : 0;
2163 +
2164 +       raw_inode->uid = BEOS_DEFAULT_UID;
2165 +       raw_inode->gid = BEOS_DEFAULT_GID;
2166 +
2167 +       raw_inode->mode = inode->i_mode;
2168 +       raw_inode->flags = inode->u.beos_i.i_flags;
2169 +
2170 +       raw_inode->create_time = ((__u64) inode->i_ctime) << 16;
2171 +       raw_inode->last_modified_time = ((__u64) inode->i_mtime) << 16;
2172 +
2173 +       raw_inode->parent = inode->u.beos_i.i_parent;
2174 +       raw_inode->attributes = inode->u.beos_i.i_attribute;
2175 +
2176 +       raw_inode->type = inode->u.beos_i.i_type;
2177 +
2178 +       raw_inode->inode_size = inode->i_blksize;
2179 +
2180 +       if (!S_ISLNK(inode->i_mode))
2181 +               raw_inode->data.datastream = inode->u.beos_i.i_data.ds;
2182 +       else
2183 +               memcpy (raw_inode->data.symlink, inode->u.beos_i.i_data.symlink,
2184 +                       BEOS_SYMLINK_LEN);
2185 +
2186 +       mark_buffer_dirty (bh, 1);
2187 +
2188 +       if (do_sync) {
2189 +               ll_rw_block (WRITE, 1, &bh);
2190 +               wait_on_buffer (bh);
2191 +               if (buffer_req (bh) && !buffer_uptodate (bh)) {
2192 +                       printk (KERN_ERR "BEOS: "
2193 +                               "IO error syncing inode [%s: %08lx]\n",
2194 +                               bdevname(inode->i_dev), inode->i_ino);
2195 +                       err = -EIO;
2196 +               }
2197 +       }
2198 +       brelse (bh);
2199 +
2200 +       return err;
2201 +}
2202 +
2203 +
2204 +void beos_write_inode (struct inode * inode)
2205 +{
2206 +       beos_update_inode (inode, 0);
2207 +}
2208 +
2209 +int beos_sync_inode (struct inode *inode)
2210 +{
2211 +       return beos_update_inode (inode, 1);
2212 +}
2213 +#endif
2214 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/namei.c linux-2.2.18-pre2-beos/fs/beos/namei.c
2215 --- linux-2.2.18-pre2-clean/fs/beos/namei.c     Wed Dec 31 18:00:00 1969
2216 +++ linux-2.2.18-pre2-beos/fs/beos/namei.c      Sat Sep  2 12:26:55 2000
2217 @@ -0,0 +1,301 @@
2218 +/*
2219 + *  linux/fs/beos/namei.c
2220 + *
2221 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
2222 + *
2223 + *  from
2224 + *
2225 + *  linux/fs/minix/namei.c
2226 + *
2227 + *  Copyright (C) 1991, 1992  Linus Torvalds
2228 + */
2229 +
2230 +#include <asm/uaccess.h>
2231 +
2232 +#include <linux/errno.h>
2233 +#include <linux/fs.h>
2234 +#include <linux/fcntl.h>
2235 +#include <linux/sched.h>
2236 +#include <linux/stat.h>
2237 +#include <linux/string.h>
2238 +#include <linux/locks.h>
2239 +#include <linux/quotaops.h>
2240 +
2241 +
2242 +/*
2243 + * beos_find_entry
2244 + *
2245 + * description:
2246 + *  find file or directory entry
2247 + *
2248 + * parameter:
2249 + *  dir     ... parent's inode
2250 + *  name    ... file or directry name
2251 + *  namelen ... length of name
2252 + */
2253 +
2254 +static beos_off_t beos_find_entry (struct inode * dir, const char * const name,
2255 +       int namelen)
2256 +{
2257 +       struct buffer_head *    bh;
2258 +       beos_index_node *       bn;
2259 +       struct super_block *    sb = dir->i_sb;
2260 +       int                     sd_pos = 0;
2261 +       int                     key_pos;
2262 +       char                    key[BEOS_NAME_LEN + 1];
2263 +       int                     key_len;
2264 +       beos_off_t              value;
2265 +
2266 +       // BEOS_OUTPUT (
2267 +       printk("BEOS ---> beos_find_entry()\n");
2268 +
2269 +       while (sd_pos >= 0)
2270 +       {
2271 +               beos_data_stream *      ds = &dir->u.beos_i.i_data.ds;
2272 +               beos_inode_addr         iaddr;
2273 +               int                     flags;
2274 +               beos_off_t              offset;
2275 +
2276 +               /*
2277 +                * get index node from small_data.
2278 +                *
2279 +                * First data stream has index entry, but other than it,
2280 +                * doesn't have it.
2281 +                */
2282 +
2283 +               if (sd_pos)
2284 +                       flags = 1;
2285 +               else
2286 +                       flags = 0;
2287 +
2288 +               iaddr = beos_read_data_stream (sb, ds, &sd_pos);
2289 +               if (sd_pos <= 0)
2290 +               {
2291 +                       /*
2292 +                        * cannot read next data stream
2293 +                        */
2294 +
2295 +                       //BEOS_OUTPUT (
2296 +                       printk(
2297 +                       "BEOS <--- beos_find_entry() cannot read next data stream\n");
2298 +                       return 0;
2299 +               }
2300 +
2301 +               bh = beos_read_index_node (iaddr, sb, flags, &offset);
2302 +               if (!bh)
2303 +               {
2304 +                       /*
2305 +                        * cannot read index node
2306 +                        */
2307 +
2308 +                       //BEOS_OUTPUT (
2309 +                       printk(
2310 +                       "BEOS <--- beos_find_entry() cannot read index node\n");
2311 +                       return 0;
2312 +               }
2313 +
2314 +               bn = (beos_index_node *) (bh->b_data + offset);
2315 +
2316 +               /*
2317 +                * explore in this block
2318 +                */
2319 +
2320 +               key_pos = 0;
2321 +               while (key_pos >= 0)
2322 +               {
2323 +                       beos_get_key_from_index_node (bn, &key_pos,
2324 +                               sb->u.beos_sb.mount_opts.beos_type, key,
2325 +                               &key_len, &value);
2326 +                       if (key_pos < 0)
2327 +                       {
2328 +                               //BEOS_OUTPUT (
2329 +                               printk("BEOS: key not exist in this block\n");
2330 +                               break;
2331 +                       }
2332 +
2333 +                       if (!strcmp (key, name))
2334 +                       {
2335 +                               brelse (bh);
2336 +                               //BEOS_OUTPUT (
2337 +                               printk(
2338 +                               "BEOS <--- beos_find_entry() value = %Lu\n", value);
2339 +                               return value;
2340 +                       }
2341 +               }
2342 +
2343 +               brelse (bh);
2344 +       }
2345 +
2346 +       //BEOS_OUTPUT (
2347 +       printk("BEOS <--- beos_find_entry() not found\n");
2348 +       return 0;
2349 +}
2350 +
2351 +
2352 +#if 0
2353 +struct dentry *beos_lookup(struct inode * dir, struct dentry *dentry)
2354 +{
2355 +       struct inode *          inode = NULL;
2356 +       beos_off_t              offset;
2357 +       unsigned int            len = dentry->d_name.len;
2358 +       int                     olen;
2359 +       const unsigned char *   tmpname = dentry->d_name.name;
2360 +       //char                  tmpname2;
2361 +       char *                  tmpname2;
2362 +       struct super_block *    sb = dir->i_sb;
2363 +
2364 +       //BEOS_OUTPUT (
2365 +       printk(
2366 +       "BEOS ---> beos_lookup() name '%s' index inode '%ld'\n", tmpname, dir->i_ino);
2367 +
2368 +       /*
2369 +        * Convert to UTF-8
2370 +        */
2371 +       // char * beos_nls2utf (unsigned char * src, int srclen, char ** dist,
2372 +       // int * len, struct super_block * sb)
2373 +
2374 +       if (!beos_nls2utf (*tmpname, len, &tmpname2, &olen, sb))
2375 +       {
2376 +               printk(
2377 +               KERN_ERR "BEOS beos_lookup() unable to allocate memory\n");
2378 +               return ERR_PTR(-ENOMEM);
2379 +       }
2380 +
2381 +       if (olen > BEOS_NAME_LEN)
2382 +       {
2383 +               printk(
2384 +               KERN_ERR "BEOS beos_lookup() name too long: '\"%s\"'",tmpname2);
2385 +               putname (tmpname2);
2386 +               return ERR_PTR(-ENAMETOOLONG);
2387 +       }
2388 +
2389 +       offset = beos_find_entry (dir, tmpname2, olen);
2390 +       putname (tmpname2);
2391 +
2392 +       if (offset)
2393 +       {
2394 +               inode = iget (sb, (ino_t) offset);
2395 +               if (!inode)
2396 +               {
2397 +                       return ERR_PTR(-EACCES);
2398 +               }
2399 +       }
2400 +
2401 +       d_add (dentry, inode);
2402 +
2403 +       //BEOS_OUTPUT (
2404 +       printk("BEOS <--- beos_lookup()\n");
2405 +
2406 +       return;
2407 +}
2408 +#endif
2409 +
2410 +
2411 +struct dentry *beos_lookup (struct inode * dir, struct dentry *dentry)
2412 +{
2413 +       struct inode *          inode = NULL;
2414 +       beos_off_t              offset;
2415 +       unsigned int            len = dentry->d_name.len;
2416 +       int                     olen;
2417 +       //const unsigned char * tmpname = dentry->d_name.name;
2418 +       char *                  tmpname = dentry->d_name.name;
2419 +       char *                  tmpname2;
2420 +       struct super_block *    sb = dir->i_sb;
2421 +
2422 +       //BEOS_OUTPUT (
2423 +       printk(
2424 +       "BEOS ---> beos_lookup() name '%s' index inode '%ld'\n", tmpname, dir->i_ino);
2425 +
2426 +       /*
2427 +        * Convert to UTF-8
2428 +        */
2429 +
2430 +       if (!beos_nls2utf (tmpname, len, &tmpname2, &olen, sb))
2431 +       {
2432 +               return ERR_PTR(-ENOMEM);
2433 +       }
2434 +
2435 +       if (olen > BEOS_NAME_LEN)
2436 +       {
2437 +               printk("BEOS beos_lookup() name too long: '\"%s\"'",tmpname2);
2438 +               putname (tmpname2);
2439 +               return ERR_PTR(-ENAMETOOLONG);
2440 +       }
2441 +
2442 +       printk("BEOS beos_lookup() name len %i\n",olen);
2443 +
2444 +       offset = beos_find_entry (dir, tmpname2, olen);
2445 +       putname (tmpname2);
2446 +
2447 +       if (offset)
2448 +       {
2449 +               inode = iget (sb, (ino_t) offset);
2450 +               if (!inode)
2451 +               {
2452 +                       return ERR_PTR(-EACCES);
2453 +               }
2454 +       }
2455 +
2456 +       d_add (dentry, inode);
2457 +
2458 +       //BEOS_OUTPUT (
2459 +       printk("BEOS <--- beos_lookup()\n");
2460 +
2461 +       return NULL;
2462 +}
2463 +
2464 +
2465 +#if 0
2466 +int beos_lookup (struct inode * dir, struct dentry *dentry)
2467 +{
2468 +       struct inode *          inode = NULL;
2469 +       beos_off_t              offset;
2470 +       unsigned int            len = dentry->d_name.len;
2471 +       int                     olen;
2472 +       //const unsigned char * tmpname = dentry->d_name.name;
2473 +       char *                  tmpname = dentry->d_name.name;
2474 +       char *                  tmpname2;
2475 +       struct super_block *    sb = dir->i_sb;
2476 +
2477 +       //BEOS_OUTPUT (
2478 +       printk(
2479 +       "BEOS ---> beos_lookup() name '%s' index inode '%ld'\n", tmpname, dir->i_ino);
2480 +
2481 +       /*
2482 +        * Convert to UTF-8
2483 +        */
2484 +
2485 +       if (!beos_nls2utf (tmpname, len, &tmpname2, &olen, sb))
2486 +       {
2487 +               return -ENOMEM;
2488 +       }
2489 +
2490 +       if (olen > BEOS_NAME_LEN)
2491 +       {
2492 +               printk("BEOS beos_lookup() name too long: '\"%s\"'",tmpname2);
2493 +               putname (tmpname2);
2494 +               return -ENAMETOOLONG;
2495 +       }
2496 +
2497 +       printk("BEOS beos_lookup() name len %i\n",olen);
2498 +
2499 +       offset = beos_find_entry (dir, tmpname2, olen);
2500 +       putname (tmpname2);
2501 +
2502 +       if (offset)
2503 +       {
2504 +               inode = iget (sb, (ino_t) offset);
2505 +               if (!inode)
2506 +               {
2507 +                       return -EACCES;
2508 +               }
2509 +       }
2510 +
2511 +       d_add (dentry, inode);
2512 +
2513 +       //BEOS_OUTPUT (
2514 +       printk("BEOS <--- beos_lookup()\n");
2515 +
2516 +       return 0;
2517 +}
2518 +#endif
2519 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/super.c linux-2.2.18-pre2-beos/fs/beos/super.c
2520 --- linux-2.2.18-pre2-clean/fs/beos/super.c     Wed Dec 31 18:00:00 1969
2521 +++ linux-2.2.18-pre2-beos/fs/beos/super.c      Mon Aug 28 18:02:08 2000
2522 @@ -0,0 +1,474 @@
2523 +/*
2524 + * linux/fs/beos/super.c
2525 + *
2526 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
2527 + *
2528 + *  from
2529 + *
2530 + *  linux/fs/minix/inode.c
2531 + *
2532 + *  Copyright (C) 1991, 1992  Linus Torvalds
2533 + */
2534 +
2535 +#include <linux/module.h>
2536 +
2537 +#include <stdarg.h>
2538 +
2539 +#include <asm/bitops.h>
2540 +#include <asm/uaccess.h>
2541 +#include <asm/system.h>
2542 +
2543 +#include <linux/errno.h>
2544 +#include <linux/fs.h>
2545 +//#include <linux/beos_fs.h>
2546 +#include <linux/malloc.h>
2547 +#include <linux/sched.h>
2548 +#include <linux/stat.h>
2549 +#include <linux/string.h>
2550 +#include <linux/locks.h>
2551 +#include <linux/blkdev.h>
2552 +#include <linux/init.h>
2553 +#include <linux/nls.h>
2554 +
2555 +
2556 +void beos_put_super (struct super_block * sb)
2557 +{
2558 +       if (sb->u.beos_sb.mount_opts.iocharset) {
2559 +               kfree (sb->u.beos_sb.mount_opts.iocharset);
2560 +               sb->u.beos_sb.mount_opts.iocharset = NULL;
2561 +       }
2562 +
2563 +       if (sb->u.beos_sb.nls) {
2564 +               unload_nls (sb->u.beos_sb.nls);
2565 +               sb->u.beos_sb.nls = NULL;
2566 +       }
2567 +
2568 +       MOD_DEC_USE_COUNT;
2569 +       return;
2570 +}
2571 +
2572 +
2573 +static const struct super_operations beos_sops =
2574 +{
2575 +       beos_read_inode,
2576 +#ifdef CONFIG_BEOS_FS_RW
2577 +       beos_write_inode,
2578 +#else
2579 +       NULL,
2580 +#endif
2581 +       NULL,   /* put */
2582 +       NULL,   /* delete */
2583 +       NULL,   /* notify */
2584 +       beos_put_super, /* put_super */
2585 +#ifdef CONFIG_BEOS_FS_RW
2586 +       NULL,   /* write_super */
2587 +#else
2588 +       NULL,
2589 +#endif
2590 +       beos_statfs,    /* stat_fs */
2591 +       beos_remount    /* remount_fs */
2592 +};
2593 +
2594 +
2595 +static int parse_options (char *, beos_mount_options *);
2596 +static void beos_convert_super_block (int, beos_super_block *, beos_super_block *);
2597 +
2598 +static int parse_options (char *options, beos_mount_options * opts)
2599 +{
2600 +       char * this_char;
2601 +       char * value;
2602 +       int    ret = 1;
2603 +
2604 +       /*
2605 +        * Initialize option.
2606 +        */
2607 +       opts->uid = 0;
2608 +       opts->gid = 0;
2609 +#ifdef CONFIG_PPC
2610 +       opts->beos_type = BEOS_PPC;
2611 +#else
2612 +       opts->beos_type = BEOS_X86;
2613 +#endif
2614 +
2615 +       if (!options)
2616 +               return ret;
2617 +
2618 +       for (this_char = strtok (options, ","); this_char != NULL;
2619 +               this_char = strtok (NULL, ",")) {
2620 +
2621 +               if ((value = strchr (this_char, '=')) != NULL)
2622 +                       *value++ = 0;
2623 +
2624 +               if (!strcmp (this_char, "uid")) {
2625 +                       if (!value || !*value) {
2626 +                               ret = 0;
2627 +                       } else {
2628 +                               opts->uid = simple_strtoul (value, &value, 0);
2629 +                               if (*value) {
2630 +                                       printk (KERN_ERR "BEOS: Invalid uid option: "
2631 +                                               "%s\n", value);
2632 +                                       ret = 0;
2633 +                               }
2634 +                       }
2635 +               } else if (!strcmp (this_char, "gid")) {
2636 +                       if (!value || !*value)
2637 +                               ret= 0;
2638 +                       else {
2639 +                               opts->gid = simple_strtoul(value, &value, 0);
2640 +                               if (*value) {
2641 +                                       printk (KERN_ERR
2642 +                                               "BEOS: Invalid gid option: "
2643 +                                               "%s\n", value);
2644 +                                       ret = 0;
2645 +                               }
2646 +                       }
2647 +#ifdef CONFIG_BEOS_CONV
2648 +               } else if (!strcmp (this_char, "type")) {
2649 +                       if (!value || !*value)
2650 +                               return 0;
2651 +                       else {
2652 +                               if (!strcmp (value, "x86")) {
2653 +                                       opts->beos_type = BEOS_X86;
2654 +                               } else if (!strcmp (value, "ppc")) {
2655 +                                       opts->beos_type = BEOS_PPC;
2656 +                               } else {
2657 +                                       printk (KERN_ERR
2658 +                                               "BEOS: unknown filesystem"
2659 +                                               " type: %s\n", value);
2660 +                                       ret = 0;
2661 +                               }
2662 +                       }
2663 +#endif
2664 +               } else if (!strcmp (this_char,"iocharset") && value) {
2665 +                       char * p = value;
2666 +                       int    len;
2667 +
2668 +                       while (*value && *value != ',')
2669 +                               value++;
2670 +                       len = value - p;
2671 +                       if (len) {
2672 +                               char * buffer = kmalloc (len+1, GFP_KERNEL);
2673 +                               if (buffer) {
2674 +                                       opts->iocharset = buffer;
2675 +                                       memcpy (buffer, p, len);
2676 +                                       buffer[len] = 0;
2677 +
2678 +                                       printk (KERN_INFO
2679 +                                               "BEOS: IO charset %s\n", buffer);
2680 +                               } else {
2681 +                                       printk (KERN_ERR
2682 +                                               "BEOS: cannot allocate memory\n");
2683 +                                       ret = 0;
2684 +                               }
2685 +                       }
2686 +               }
2687 +       }
2688 +
2689 +       return ret;
2690 +}
2691 +
2692 +
2693 +/*
2694 + * Convert big-endian <-> little-endian
2695 + */
2696 +
2697 +static void beos_convert_super_block (int fstype, beos_super_block * bs,
2698 +       beos_super_block * out)
2699 +{
2700 +       switch (fstype)
2701 +       {
2702 +       case BEOS_X86:
2703 +               out->magic1 = le32_to_cpu(bs->magic1);
2704 +               out->block_size = le32_to_cpu(bs->block_size);
2705 +               out->block_shift = le32_to_cpu(bs->block_shift);
2706 +               out->num_blocks = le64_to_cpu(bs->num_blocks);
2707 +               out->used_blocks = le64_to_cpu(bs->used_blocks);
2708 +               out->inode_size = le32_to_cpu(bs->inode_size);
2709 +               out->magic2 = le32_to_cpu(bs->magic2);
2710 +               out->blocks_per_ag = le32_to_cpu(bs->blocks_per_ag);
2711 +               out->ag_shift = le32_to_cpu(bs->ag_shift);
2712 +               out->num_ags = le32_to_cpu(bs->num_ags);
2713 +               out->flags = le32_to_cpu(bs->flags);
2714 +               beos_convert_inodeaddr (fstype, &(bs->log_blocks),
2715 +                       &(out->log_blocks));
2716 +               out->log_start = le64_to_cpu(bs->log_start);
2717 +               out->log_end = le64_to_cpu(bs->log_end);
2718 +               out->magic3 = le32_to_cpu(bs->magic3);
2719 +               beos_convert_inodeaddr (fstype, &(bs->root_dir),
2720 +                       &(out->root_dir));
2721 +               beos_convert_inodeaddr (fstype, &(bs->indices),
2722 +                       &(out->indices));
2723 +               break;
2724 +
2725 +       case BEOS_PPC:
2726 +               out->magic1 = be32_to_cpu(bs->magic1);
2727 +               out->block_size = be32_to_cpu(bs->block_size);
2728 +               out->block_shift = be32_to_cpu(bs->block_shift);
2729 +               out->num_blocks = be64_to_cpu(bs->num_blocks);
2730 +               out->used_blocks = be64_to_cpu(bs->used_blocks);
2731 +               out->inode_size = be32_to_cpu(bs->inode_size);
2732 +               out->magic2 = be32_to_cpu(bs->magic2);
2733 +               out->blocks_per_ag = be32_to_cpu(bs->blocks_per_ag);
2734 +               out->ag_shift = be32_to_cpu(bs->ag_shift);
2735 +               out->num_ags = be32_to_cpu(bs->num_ags);
2736 +               out->flags = be32_to_cpu(bs->flags);
2737 +               beos_convert_inodeaddr (fstype, &(bs->log_blocks),
2738 +                       &(out->log_blocks));
2739 +               out->log_start = be64_to_cpu(bs->log_start);
2740 +               out->log_end = be64_to_cpu(bs->log_end);
2741 +               out->magic3 = be32_to_cpu(bs->magic3);
2742 +               beos_convert_inodeaddr (fstype, &(bs->root_dir),
2743 +                       &(out->root_dir));
2744 +               beos_convert_inodeaddr (fstype, &(bs->indices),
2745 +                       &(out->indices));
2746 +               break;
2747 +       }
2748 +}
2749 +
2750 +
2751 +struct super_block * beos_read_super (struct super_block *sb, void *data,
2752 +       int silent )
2753 +{
2754 +       beos_super_block *      bs = NULL;
2755 +       kdev_t                  dev = sb->s_dev;
2756 +       int                     blocksize;
2757 +       unsigned long           logic_sb_block;
2758 +       struct buffer_head *    bh;
2759 +
2760 +       BEOS_OUTPUT (("---> beos_read_super()\n"));
2761 +
2762 +       /*
2763 +        * Parse options
2764 +        */
2765 +
2766 +       if (!parse_options ((char*) data, &sb->u.beos_sb.mount_opts)) {
2767 +               printk (KERN_ERR "BEOS: cannot parse mount options\n");
2768 +               return NULL;
2769 +       }
2770 +
2771 +       /*
2772 +        * Set dummy blocksize to read super block.
2773 +        */
2774 +
2775 +       switch (BEOS_TYPE(sb))
2776 +       {
2777 +       case BEOS_X86:
2778 +               blocksize = 512;
2779 +               logic_sb_block = 1;
2780 +               break;
2781 +
2782 +       case BEOS_PPC:
2783 +               blocksize = 1024;
2784 +               logic_sb_block = 0;
2785 +               break;
2786 +
2787 +       default:
2788 +               printk (KERN_ERR "BEOS: cannot parse filesystem type\n");
2789 +               return NULL;
2790 +       }
2791 +
2792 +       MOD_INC_USE_COUNT;
2793 +       lock_super (sb);
2794 +       set_blocksize (dev, blocksize);
2795 +
2796 +       /*
2797 +        * Get BEOS super block.
2798 +        */
2799 +
2800 +       if (!(bh = bread (dev, logic_sb_block, blocksize))) {
2801 +               printk (KERN_ERR "BEOS: unable to read superblock\n");
2802 +               goto bad_beos_read_super;
2803 +       }
2804 +
2805 +       bs = (beos_super_block *) bh->b_data;
2806 +
2807 +#ifdef CONFIG_BEOS_CONV
2808 +       /*
2809 +        * Convert byte order
2810 +        */
2811 +
2812 +       bs = (beos_super_block *) __getname();
2813 +       if (!bs) {
2814 +               brelse(bh);
2815 +               goto bad_beos_read_super;
2816 +       }
2817 +       beos_convert_super_block (BEOS_TYPE(sb),
2818 +               (beos_super_block *) bh->b_data, bs);
2819 +#endif
2820 +       BEOS_DUMP_SUPER_BLOCK (bs);
2821 +
2822 +       /*
2823 +        * Check magic headers of super block
2824 +        */
2825 +
2826 +       if ((bs->magic1 != BEOS_SUPER_BLOCK_MAGIC1)
2827 +               || (bs->magic2 != BEOS_SUPER_BLOCK_MAGIC2)
2828 +               || (bs->magic3 != BEOS_SUPER_BLOCK_MAGIC3)) {
2829 +
2830 +               brelse (bh);
2831 +               printk (KERN_ERR "BEOS: different magic header\n");
2832 +               goto bad_beos_read_super;
2833 +       }
2834 +
2835 +       /*
2836 +        * Check blocksize of BEOS.
2837 +        *
2838 +        * Blocksize of BEOS is 1024, 2048, 4096 or 8192.
2839 +        */
2840 +
2841 +       if( (bs->block_size != 1024)
2842 +               && (bs->block_size != 2048)
2843 +               && (bs->block_size != 4096)
2844 +               && (bs->block_size != 8192)) {
2845 +
2846 +               brelse (bh);
2847 +               printk (KERN_ERR "BEOS: different blocksize\n");
2848 +               goto bad_beos_read_super;
2849 +       }
2850 +
2851 +       set_blocksize (dev, (int) bs->block_size);
2852 +
2853 +       /*
2854 +        * fill in standard stuff
2855 +        */
2856 +
2857 +       sb->s_magic = BEOS_SUPER_MAGIC;
2858 +       sb->s_blocksize = (int) bs->block_size;
2859 +
2860 +       sb->u.beos_sb.block_size = bs->block_size;
2861 +       sb->u.beos_sb.block_shift = bs->block_shift;
2862 +       sb->u.beos_sb.num_blocks = bs->num_blocks;
2863 +       sb->u.beos_sb.used_blocks = bs->used_blocks;
2864 +       sb->u.beos_sb.inode_size = bs->inode_size;
2865 +
2866 +       sb->u.beos_sb.blocks_per_ag = bs->blocks_per_ag;
2867 +       sb->u.beos_sb.ag_shift = bs->ag_shift;
2868 +       sb->u.beos_sb.num_ags = bs->num_ags;
2869 +
2870 +       sb->u.beos_sb.log_blocks = bs->log_blocks;
2871 +       sb->u.beos_sb.log_start = bs->log_start;
2872 +       sb->u.beos_sb.log_end = bs->log_end;
2873 +
2874 +       sb->u.beos_sb.root_dir = bs->root_dir;
2875 +       sb->u.beos_sb.indices = bs->indices;
2876 +
2877 +       unlock_super (sb);
2878 +
2879 +       /*
2880 +        * set up enough so that it can read an inode
2881 +        */
2882 +
2883 +       sb->s_dev = dev;
2884 +       sb->s_op = (struct super_operations *) &beos_sops;
2885 +       sb->s_root = d_alloc_root (iget (sb,
2886 +               BEOS_IADDR2INO(&(bs->root_dir),bs)), NULL);
2887 +
2888 +       if (!sb->s_root) {
2889 +               sb->s_dev = 0;
2890 +               brelse (bh);
2891 +               printk (KERN_ERR "BEOS: get root inode failed\n");
2892 +
2893 +               goto uninit_last_beos_read_super;
2894 +       }
2895 +
2896 +       /*
2897 +        * load nls library
2898 +        */
2899 +
2900 +       if (sb->u.beos_sb.mount_opts.iocharset) {
2901 +               sb->u.beos_sb.nls =
2902 +                       load_nls (sb->u.beos_sb.mount_opts.iocharset);
2903 +               if (!sb->u.beos_sb.nls) {
2904 +                       printk (KERN_WARNING "BEOS: cannot load nls/iocharset '%s.' Loading default nls\n",sb->u.beos_sb.mount_opts.iocharset);
2905 +                       sb->u.beos_sb.nls = load_nls_default ();
2906 +               }
2907 +               else
2908 +               {
2909 +                       printk (KERN_INFO "BEOS: loaded nls/iocharset '%s'\n",
2910 +                               sb->u.beos_sb.mount_opts.iocharset);
2911 +               }
2912 +       }
2913 +       //else {
2914 +       //}
2915 +
2916 +       brelse (bh);
2917 +#ifdef CONFIG_BEOS_CONV
2918 +       putname (bs);
2919 +#endif
2920 +
2921 +       return sb;
2922 +
2923 +bad_beos_read_super:
2924 +       sb->s_dev = 0;
2925 +       unlock_super (sb);
2926 +
2927 +uninit_last_beos_read_super:
2928 +#ifdef CONFIG_BEOS_CONV
2929 +       if (bs)
2930 +               putname (bs);
2931 +#endif
2932 +       MOD_DEC_USE_COUNT;
2933 +
2934 +       return NULL;
2935 +}
2936 +
2937 +
2938 +int beos_remount (struct super_block * sb, int * flags, char * data)
2939 +{
2940 +       if (!(*flags & MS_RDONLY))
2941 +               return -EINVAL;
2942 +       return 0;
2943 +}
2944 +
2945 +
2946 +static struct file_system_type beos_fs_type = {
2947 +       "beos",
2948 +       FS_REQUIRES_DEV,
2949 +       beos_read_super,
2950 +       NULL
2951 +};
2952 +
2953 +
2954 +__initfunc(int init_beos_fs(void))
2955 +{
2956 +       return register_filesystem(&beos_fs_type);
2957 +}
2958 +
2959 +#ifdef MODULE
2960 +MODULE_AUTHOR ("Miles Lott, milos@insync.net");
2961 +MODULE_DESCRIPTION ("BeOS FS Driver for Linux (c)2000");
2962 +EXPORT_NO_SYMBOLS;
2963 +
2964 +int init_module(void)
2965 +{
2966 +       printk(KERN_INFO "BEOS: BeOS FS support - http://milosch.net/beos\n");
2967 +       return init_beos_fs();
2968 +}
2969 +
2970 +
2971 +void cleanup_module(void)
2972 +{
2973 +       unregister_filesystem(&beos_fs_type);
2974 +       printk(KERN_INFO "BEOS: BeOS FS support unregistered\n");
2975 +}
2976 +
2977 +#endif
2978 +
2979 +
2980 +int beos_statfs (struct super_block * sb, struct statfs * buf, int bufsiz)
2981 +{
2982 +       struct statfs tmp;
2983 +
2984 +       BEOS_OUTPUT (("---> beos_statfs()\n"));
2985 +
2986 +       tmp.f_type = BEOS_SUPER_MAGIC;
2987 +       tmp.f_bsize = sb->s_blocksize;
2988 +       tmp.f_blocks = sb->u.beos_sb.num_blocks;
2989 +       tmp.f_bfree = sb->u.beos_sb.num_blocks - sb->u.beos_sb.used_blocks;
2990 +       tmp.f_bavail = sb->u.beos_sb.num_blocks - sb->u.beos_sb.used_blocks;
2991 +       tmp.f_files = 0;
2992 +       tmp.f_ffree = 0;
2993 +       tmp.f_namelen = BEOS_NAME_LEN;
2994 +
2995 +       return copy_to_user (buf, &tmp, bufsiz) ? -EFAULT : 0;
2996 +}
2997 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/symlink.c linux-2.2.18-pre2-beos/fs/beos/symlink.c
2998 --- linux-2.2.18-pre2-clean/fs/beos/symlink.c   Wed Dec 31 18:00:00 1969
2999 +++ linux-2.2.18-pre2-beos/fs/beos/symlink.c    Sun Aug 27 08:49:32 2000
3000 @@ -0,0 +1,95 @@
3001 +/*
3002 + *  linux/fs/beos/symlink.c
3003 + *
3004 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
3005 + *
3006 + *  from
3007 + *
3008 + *  linux/fs/minix/symlink.c
3009 + *
3010 + *  Copyright (C) 1991, 1992  Linus Torvalds
3011 + */
3012 +
3013 +#include <asm/uaccess.h>
3014 +
3015 +#include <linux/errno.h>
3016 +#include <linux/fs.h>
3017 +#include <linux/beos_fs.h>
3018 +#include <linux/sched.h>
3019 +#include <linux/mm.h>
3020 +#include <linux/stat.h>
3021 +
3022 +static int beos_readlink (struct dentry *, char *, int);
3023 +static struct dentry * beos_follow_link(struct dentry *, struct dentry *,
3024 +       unsigned int);
3025 +
3026 +/*
3027 + * symlinks can't do much...
3028 + */
3029 +struct inode_operations beos_symlink_inode_operations = {
3030 +        NULL,                   /* no file-operations */
3031 +        NULL,                   /* create */
3032 +        NULL,                   /* lookup */
3033 +        NULL,                   /* link */
3034 +        NULL,                   /* unlink */
3035 +        NULL,                   /* symlink */
3036 +        NULL,                   /* mkdir */
3037 +        NULL,                   /* rmdir */
3038 +        NULL,                   /* mknod */
3039 +       NULL,                   /* rename */
3040 +       beos_readlink,          /* readlink */
3041 +        beos_follow_link,       /* follow_link */
3042 +        NULL,                   /* readpage */
3043 +        NULL,                   /* writepage */
3044 +        NULL,                   /* bmap */
3045 +        NULL,                   /* truncate */
3046 +        NULL,                   /* permission */
3047 +        NULL                    /* smap */
3048 +};
3049 +
3050 +
3051 +/*
3052 + * The inode of symbolic link is different to data stream.
3053 + * The data stream become link name.
3054 + */
3055 +static struct dentry * beos_follow_link(struct dentry * dentry,
3056 +       struct dentry * base, unsigned int follow)
3057 +{
3058 +        struct inode * inode = dentry->d_inode;
3059 +        char *         link = inode->u.beos_i.i_data.symlink;
3060 +
3061 +        UPDATE_ATIME(inode);
3062 +
3063 +        base = lookup_dentry (link, base, follow);
3064 +
3065 +        return base;
3066 +}
3067 +
3068 +
3069 +static int beos_readlink (struct dentry * dentry, char * buffer, int buflen)
3070 +{
3071 +        struct inode * inode = dentry->d_inode;
3072 +        char *         link = inode->u.beos_i.i_data.symlink;
3073 +        int            len = 0;
3074 +        int            len_dist;
3075 +       char *         tmpname;
3076 +
3077 +        if (buflen > BEOS_SYMLINK_LEN)
3078 +                buflen = BEOS_SYMLINK_LEN;
3079 +
3080 +        while (len < buflen && link[len])
3081 +                len++;
3082 +
3083 +       if (!beos_utf2nls (link, len, &tmpname, &len_dist, inode->i_sb)) {
3084 +               return -ENOMEM;
3085 +       }
3086 +
3087 +        if (copy_to_user(buffer, tmpname, len_dist))
3088 +                len = -EFAULT;
3089 +
3090 +       putname (tmpname);
3091 +
3092 +        UPDATE_ATIME(inode);
3093 +
3094 +        return len;
3095 +}
3096 diff -aur --new-file linux-2.2.18-pre2-clean/fs/beos/util.c linux-2.2.18-pre2-beos/fs/beos/util.c
3097 --- linux-2.2.18-pre2-clean/fs/beos/util.c      Wed Dec 31 18:00:00 1969
3098 +++ linux-2.2.18-pre2-beos/fs/beos/util.c       Sat Sep  2 12:37:55 2000
3099 @@ -0,0 +1,162 @@
3100 +/*
3101 + *  linux/fs/beos/util.c
3102 + *
3103 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
3104 + */
3105 +
3106 +#include <linux/mm.h>
3107 +#include <linux/fs.h>
3108 +#include <linux/nls.h>
3109 +
3110 +#define BEOS_UNKNOWN_CHAR '?'
3111 +
3112 +
3113 +/*
3114 + * UTF-8 to NLS charset  convert routine
3115 + */
3116 +char * beos_utf2nls (char * src, int srclen, char ** dist,
3117 +               int * len, struct super_block * sb)
3118 +{
3119 +       char *                  out;
3120 +       struct nls_table *      nls = sb->u.beos_sb.nls;
3121 +       char *                  orig = src;
3122 +       int                     olen = 0;
3123 +
3124 +       BEOS_OUTPUT (("---> utf2nls()\n"));
3125 +
3126 +       *dist = out = (char *) __getname();
3127 +
3128 +       if (!out)
3129 +       {
3130 +               printk(KERN_ERR "BEOS utf2nls: cannot allocate memory\n");
3131 +               return NULL;
3132 +       }
3133 +
3134 +       if (!nls)
3135 +       {
3136 +               printk(KERN_INFO "BEOS utf2nls: '%s' not nls\n", src);
3137 +               while (*src && srclen-- > 0) { *out++ = *src++; }
3138 +       }
3139 +       else
3140 +       {
3141 +               printk(KERN_INFO "BEOS utf2nls: processing nls\n");
3142 +               while (*src && srclen > 0)
3143 +               {
3144 +                       int n;
3145 +                       unsigned char           page;
3146 +                       __u16                   w;
3147 +
3148 +                       /*
3149 +                        *  convert from UTF-8 to Unicode
3150 +                        */
3151 +                       // int utf8_mbtowc(__u16 *, const __u8 *, int)
3152 +                       n = utf8_mbtowc(&w, src, srclen);
3153 +                       if (n <= 0)
3154 +                       {
3155 +                               /*
3156 +                                * cannot convert from UTF-8 to unicode
3157 +                                */
3158 +                               *out++ = BEOS_UNKNOWN_CHAR;
3159 +                               src++;
3160 +                               srclen--;
3161 +                               continue;
3162 +                       }
3163 +                       //else
3164 +                       //{
3165 +                       //      printk(KERN_INFO "BEOS utf8_mbtowc: %d\n",w);
3166 +                       //}
3167 +                       src += n;
3168 +                       srclen -= n;
3169 +
3170 +               //      printk(KERN_INFO "BEOS uni2char: working on %d\n",w);
3171 +                       nls->uni2char(0x00, w, &page, 20, &olen);
3172 +               //      printk(KERN_INFO "BEOS uni2char: returned %d\n",page);
3173 +
3174 +                       if (!page)
3175 +                               *out++ = BEOS_UNKNOWN_CHAR;
3176 +                       else
3177 +                               //*out++ = page[w & 0xff];
3178 +                               *out++ = page;
3179 +               }
3180 +       }
3181 +       *out = '\0';
3182 +       *len = out - (*dist);
3183 +
3184 +       BEOS_OUTPUT (("<--- utf2nls()\n"));
3185 +       if (nls)
3186 +       {
3187 +               printk(KERN_INFO "BEOS utf2nls in '%s'\tout '%s' length '%d'\n", orig, *dist, *len);
3188 +       }
3189 +       return *dist;
3190 +}
3191 +
3192 +
3193 +char * beos_nls2utf (unsigned char * src, int srclen, char ** dist,
3194 +               int * len, struct super_block * sb)
3195 +{
3196 +       char *                  out;
3197 +       struct nls_table *      nls = sb->u.beos_sb.nls;
3198 +       char *                  orig = src;
3199 +
3200 +       //BEOS_OUTPUT (
3201 +       printk(KERN_INFO "BEOS ---> nls2utf()\n");
3202 +
3203 +       *dist = out = (char *) __getname();
3204 +       if (!out)
3205 +       {
3206 +               //BEOS_OUTPUT (
3207 +               printk(KERN_WARNING "BEOS: cannot allocate memory\n");
3208 +               return NULL;
3209 +       }
3210 +
3211 +       if (!nls)
3212 +       {
3213 +               printk(KERN_INFO "BEOS nls2utf: not nls\n");
3214 +               while (*src && srclen-- > 0) { *out++ = *src++; }
3215 +       }
3216 +       else
3217 +       {
3218 +               printk(KERN_INFO "BEOS nls2utf: processing nls\n");
3219 +               while (*src && srclen > 0)
3220 +               {
3221 +                       int             n,offset=0;
3222 +                       __u16           w=0;
3223 +                       __u8            wl,wh;
3224 +
3225 +                       /*
3226 +                        * convert from nls to unicode
3227 +                        */
3228 +               //      printk(KERN_INFO "BEOS char2uni: working on %d\n",*src);
3229 +                       nls->char2uni(src, &offset, &wh, &wl);
3230 +               //      printk(KERN_INFO "BEOS char2uni: returned %d\n",wh);
3231 +
3232 +                       src++;
3233 +                       srclen--;
3234 +                       //w = wh >> 8 << wl;
3235 +                       w = wh;
3236 +                       //printk(KERN_INFO "BEOS char2uni: %d\n",w);
3237 +                       /*
3238 +                        * convert from unicode to UTF-8
3239 +                        */
3240 +                       n = utf8_wctomb(out, w, 6);
3241 +                       if (n <= 0)
3242 +                       {
3243 +                               *out++ = BEOS_UNKNOWN_CHAR;
3244 +                               continue;
3245 +                       }
3246 +                       out += n;
3247 +               }
3248 +       }
3249 +
3250 +       *out = '\0';
3251 +       *len = out - (*dist);
3252 +
3253 +       //BEOS_OUTPUT (
3254 +       printk(KERN_INFO "BEOS <--- nls2utf()\n");
3255 +       if (nls)
3256 +       {
3257 +               printk(
3258 +               KERN_INFO "BEOS nls2utf in '%s'\tout '%s' length '%d'\n", orig, *dist,*len);
3259 +       }
3260 +       return *dist;
3261 +}
3262 diff -aur --new-file linux-2.2.18-pre2-clean/fs/filesystems.c linux-2.2.18-pre2-beos/fs/filesystems.c
3263 --- linux-2.2.18-pre2-clean/fs/filesystems.c    Thu Aug 24 01:54:28 2000
3264 +++ linux-2.2.18-pre2-beos/fs/filesystems.c     Sat Sep  2 12:52:02 2000
3265 @@ -59,6 +59,10 @@
3266         init_minix_fs();
3267  #endif
3268
3269 +#ifdef CONFIG_BEOS_FS
3270 +       init_beos_fs();
3271 +#endif
3272 +
3273  #ifdef CONFIG_ROMFS_FS
3274         init_romfs_fs();
3275  #endif
3276 diff -aur --new-file linux-2.2.18-pre2-clean/include/linux/beos_fs.h linux-2.2.18-pre2-beos/include/linux/beos_fs.h
3277 --- linux-2.2.18-pre2-clean/include/linux/beos_fs.h     Wed Dec 31 18:00:00 1969
3278 +++ linux-2.2.18-pre2-beos/include/linux/beos_fs.h      Sat Sep  2 12:26:25 2000
3279 @@ -0,0 +1,305 @@
3280 +/*
3281 + * linux/include/linux/beos_fs.h
3282 + *
3283 + * Copyright (C) 1999 Makoto Kato (m_kato@ga2.so-net.ne.jp)
3284 + */
3285 +
3286 +#ifndef _LINUX_BEOS_FS
3287 +#define _LINUX_BEOS_FS
3288 +
3289 +#include <linux/types.h>
3290 +//#include <linux/fs.h>
3291 +
3292 +/*
3293 + * for debug
3294 + */
3295 +/* #define BEOS_DEBUG */
3296 +
3297 +#ifdef BEOS_DEBUG
3298 +#define BEOS_OUTPUT(x)        printk x
3299 +#define BEOS_DUMP_SUPER_BLOCK beos_dump_super_block
3300 +#define BEOS_DUMP_INODE       beos_dump_inode
3301 +#define BEOS_DUMP_INDEX_ENTRY beos_dump_index_entry
3302 +#define BEOS_DUMP_INDEX_NODE  beos_dump_index_node
3303 +#define BEOS_DUMP_INODE_ADDR  beos_dump_inode_addr
3304 +#else
3305 +#define BEOS_OUTPUT(x)
3306 +#define BEOS_DUMP_SUPER_BLOCK(x)
3307 +#define BEOS_DUMP_INODE(x)
3308 +#define BEOS_DUMP_INDEX_ENTRY(x)
3309 +#define BEOS_DUMP_INDEX_NODE(x)
3310 +#define BEOS_DUMP_INODE_ADDR(x)
3311 +#endif
3312 +
3313 +
3314 +/*
3315 + * Flags of superblock
3316 + */
3317 +
3318 +#define BEOS_CLEAN 0x434c454e
3319 +#define BEOS_DIRTY 0x44495254
3320 +
3321 +/*
3322 + * Max name length of BEOS
3323 + */
3324 +
3325 +#define BEOS_NAME_LEN 255
3326 +#define BEOS_SYMLINK_LEN 160
3327 +
3328 +/*
3329 + * Magic headers of BEOS's superblock, inode and index
3330 + */
3331 +
3332 +#define BEOS_SUPER_BLOCK_MAGIC1 0x42465331 /* BEOS1 */
3333 +#define BEOS_SUPER_BLOCK_MAGIC2 0xdd121031
3334 +#define BEOS_SUPER_BLOCK_MAGIC3 0x15b6830e
3335 +
3336 +#define BEOS_INODE_MAGIC1 0x3bbe0ad9
3337 +
3338 +#define BEOS_INDEX_MAGIC 0x69f6c2e8
3339 +
3340 +#define BEOS_SUPER_MAGIC BEOS_SUPER_BLOCK_MAGIC1
3341 +
3342 +
3343 +#define BEOS_NUM_DIRECT_BLOCKS 12
3344 +#define BEOS_NAME_LENGTH 32
3345 +
3346 +/*
3347 + * BEOS filesystem type
3348 + */
3349 +
3350 +#define BEOS_PPC 1
3351 +#define BEOS_X86 2
3352 +
3353 +/*
3354 + * default gid and uid
3355 + */
3356 +
3357 +#define BEOS_DEFAULT_GID 0
3358 +#define BEOS_DEFAULT_UID 0
3359 +
3360 +/*
3361 + * Flags of inode
3362 + */
3363 +
3364 +#define BEOS_INODE_IN_USE      0x00000001
3365 +#define BEOS_ATTR_INODE        0x00000004
3366 +#define BEOS_INODE_LOGGED      0x00000008
3367 +#define BEOS_INODE_DELETED     0x00000010
3368 +
3369 +#define BEOS_PERMANENT_FLAG    0x0000ffff
3370 +
3371 +#define BEOS_INODE_NO_CREATE   0x00010000
3372 +#define BEOS_INODE_WAS_WRITTEN 0x00020000
3373 +#define BEOS_NO_TRANSACTION    0x00040000
3374 +
3375 +
3376 +#define BEOS_IADDR2INO(iaddr,sb) \
3377 +       (((iaddr)->allocation_group << (sb)->ag_shift) + (iaddr)->start)
3378 +#define BEOS_INODE2INO(inode) \
3379 +       (((inode)->u.beos_i.i_inode_num.allocation_group << \
3380 +               (inode)->i_sb->u.beos_sb.ag_shift) \
3381 +       + (inode)->u.beos_i.i_inode_num.start)
3382 +
3383 +#define BEOS_BLOCK_PER_INODE(sb) \
3384 +       ((sb)->u.beos_sb.block_size / sizeof(beos_inode_addr))
3385 +
3386 +#define BEOS_IS_EMPTY_IADDR(iaddr) \
3387 +       ((!(iaddr)->allocation_group) && (!(iaddr)->start) && (!(iaddr)->len))
3388 +
3389 +#define BEOS_TYPE(sb) \
3390 +       ((sb)->u.beos_sb.mount_opts.beos_type)
3391 +
3392 +/*
3393 + * special type of BEOS
3394 + */
3395 +
3396 +typedef long long      beos_off_t;
3397 +typedef long long      beos_bigtime_t;
3398 +typedef void           beos_binode_etc;
3399 +
3400 +
3401 +/* Block runs */
3402 +typedef struct _beos_block_run {
3403 +       __u32   allocation_group;
3404 +       __u16   start;
3405 +       __u16   len;
3406 +} beos_block_run;
3407 +
3408 +
3409 +typedef beos_block_run beos_inode_addr;
3410 +
3411 +
3412 +/*
3413 + * The Superblock Structure
3414 + */
3415 +
3416 +typedef struct _beos_super_block {
3417 +       char    name[BEOS_NAME_LENGTH];
3418 +       __u32   magic1;
3419 +       __u32   fs_byte_order;
3420 +
3421 +       __u32   block_size;
3422 +       __u32   block_shift;
3423 +
3424 +       beos_off_t  num_blocks;
3425 +       beos_off_t  used_blocks;
3426 +
3427 +       __u32          inode_size;
3428 +
3429 +       __u32          magic2;
3430 +       __u32          blocks_per_ag;
3431 +       __u32          ag_shift;
3432 +       __u32          num_ags;
3433 +
3434 +       __u32          flags;
3435 +
3436 +       beos_block_run  log_blocks;
3437 +       beos_off_t      log_start;
3438 +       beos_off_t      log_end;
3439 +
3440 +       __u32          magic3;
3441 +       beos_inode_addr root_dir;
3442 +       beos_inode_addr indices;
3443 +
3444 +       __u32          pad[8];
3445 +} __attribute__ ((packed)) beos_super_block;
3446 +
3447 +
3448 +typedef struct _beos_data_stream {
3449 +       beos_block_run  direct[BEOS_NUM_DIRECT_BLOCKS];
3450 +       beos_off_t      max_direct_range;
3451 +       beos_block_run  indirect;
3452 +       beos_off_t      max_indirect_range;
3453 +       beos_block_run  double_indirect;
3454 +       beos_off_t      max_double_indirect_range;
3455 +       beos_off_t      size;
3456 +} __attribute__ ((packed)) beos_data_stream;
3457 +
3458 +
3459 +/* Attribute */
3460 +typedef struct _beos_small_data {
3461 +       __u32   type;
3462 +       __u16   name_size;
3463 +       __u16   data_size;
3464 +       char    name[1];
3465 +} __attribute__ ((packed)) beos_small_data;
3466 +
3467 +
3468 +/* Inode structure */
3469 +typedef struct _beos_inode {
3470 +       __u32           magic1;
3471 +       beos_inode_addr  inode_num;
3472 +       __u32           uid;
3473 +       __u32           gid;
3474 +       __u32           mode;
3475 +       __u32           flags;
3476 +       beos_bigtime_t   create_time;
3477 +       beos_bigtime_t   last_modified_time;
3478 +       beos_inode_addr  parent;
3479 +       beos_inode_addr  attributes;
3480 +       __u32           type;
3481 +
3482 +       __u32           inode_size;
3483 +       __u32           etc; /* not use */
3484 +
3485 +       union {
3486 +               beos_data_stream         datastream;
3487 +               char             symlink[BEOS_SYMLINK_LEN];
3488 +       } data;
3489 +       __u32            pad[4]; /* not use */
3490 +} __attribute__ ((packed)) beos_inode;
3491 +
3492 +
3493 +typedef struct _beos_index_entry {
3494 +       __u32      magic;
3495 +       __u32      node_size;
3496 +       __u32      max_number_of_levels;
3497 +       __u32      data_type;
3498 +       beos_off_t  root_node_pointer;
3499 +       beos_off_t  free_node_pointer;
3500 +       beos_off_t  maximum_size;
3501 +} __attribute__ ((packed)) beos_index_entry;
3502 +
3503 +
3504 +typedef struct _beos_index_node {
3505 +       beos_off_t left;
3506 +       beos_off_t right;
3507 +       beos_off_t overflow;
3508 +       __u16     all_key_count;
3509 +       __u16     all_key_length;
3510 +} __attribute__ ((packed)) beos_index_node;
3511 +
3512 +
3513 +typedef struct _beos_mount_options {
3514 +       gid_t   gid;
3515 +       uid_t   uid;
3516 +       int     beos_type;
3517 +       char *  iocharset;
3518 +} beos_mount_options;
3519 +
3520 +
3521 +#ifdef __KERNEL__
3522 +/*
3523 + * Function prototypes
3524 + */
3525 +
3526 +/* file.c */
3527 +extern int beos_read (struct inode *, struct file *, char *, int);
3528 +extern beos_inode_addr beos_read_data_stream (struct super_block *,
3529 +       beos_data_stream *, int *);
3530 +
3531 +/* inode.c */
3532 +extern int beos_bmap (struct inode *, int);
3533 +extern void beos_read_inode (struct inode *);
3534 +extern struct buffer_head * beos_bread (struct inode *);
3535 +extern struct buffer_head * beos_bread2 (struct super_block *, beos_inode_addr);
3536 +extern void beos_write_inode (struct inode *);
3537 +extern int beos_sync_inode (struct inode *);
3538 +extern void beos_convert_inodeaddr (
3539 +               int fstype, beos_inode_addr * iaddr, beos_inode_addr * out);
3540 +
3541 +/* namei.c */
3542 +extern void beos_release (struct inode *, struct file *);
3543 +//extern int beos_lookup (struct inode *, struct dentry *);
3544 +extern struct dentry * beos_lookup (struct inode *, struct dentry *);
3545 +
3546 +/* super.c */
3547 +extern void beos_put_super (struct super_block *);
3548 +extern int beos_remount (struct super_block *, int *, char *);
3549 +extern struct super_block * beos_read_super (struct super_block *,void *,int);
3550 +extern int init_beos_fs(void);
3551 +extern int beos_statfs (struct super_block *, struct statfs *, int);
3552 +
3553 +/* index.c */
3554 +extern char * beos_get_key_from_index_node (beos_index_node *, int *, int,
3555 +       char *, int *, beos_off_t *);
3556 +extern struct buffer_head * beos_read_index_node (beos_inode_addr,
3557 +       struct super_block *, int, beos_off_t *);
3558 +
3559 +/* debug.c */
3560 +extern void beos_dump_super_block (beos_super_block *);
3561 +extern void beos_dump_inode (beos_inode *);
3562 +extern void beos_dump_index_entry (beos_index_entry *);
3563 +extern void beos_dump_index_node (beos_index_node *);
3564 +
3565 +/* util.c */
3566 +extern char * beos_utf2nls (char *, int, char **, int *, struct super_block *);
3567 +extern char * beos_nls2utf (unsigned char *, int, char **, int *, struct super_block *);
3568 +
3569 +/*
3570 + * Inodes and files operations
3571 + */
3572 +
3573 +/* dir.c */
3574 +extern struct inode_operations beos_dir_inode_operations;
3575 +
3576 +/* file.c */
3577 +extern struct inode_operations beos_file_inode_operations;
3578 +
3579 +/* symlink.c */
3580 +extern struct inode_operations beos_symlink_inode_operations;
3581 +
3582 +#endif  /* __KERNEL__ */
3583 +
3584 +#endif
3585 diff -aur --new-file linux-2.2.18-pre2-clean/include/linux/beos_fs_i.h linux-2.2.18-pre2-beos/include/linux/beos_fs_i.h
3586 --- linux-2.2.18-pre2-clean/include/linux/beos_fs_i.h   Wed Dec 31 18:00:00 1969
3587 +++ linux-2.2.18-pre2-beos/include/linux/beos_fs_i.h    Sat Sep  2 12:26:30 2000
3588 @@ -0,0 +1,37 @@
3589 +/*
3590 + *  linux/include/linux/beos_fs_i.h
3591 + *
3592 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
3593 + *
3594 + *  from
3595 + *
3596 + *  linux/include/linux/ex2_fs_i.h
3597 + */
3598 +
3599 +#ifndef _LINUX_BEOS_FS_I_
3600 +#define _LINUX_BEOS_FS_I_
3601 +
3602 +#include <linux/beos_fs.h>
3603 +
3604 +struct beos_inode_info {
3605 +       beos_inode_addr i_inode_num;
3606 +       __u32   i_uid;
3607 +       __u32   i_gid;
3608 +       __u32   i_mode;
3609 +       __u32   i_flags;
3610 +
3611 +       beos_bigtime_t  i_create_time;
3612 +       beos_bigtime_t  i_last_modified_time;
3613 +
3614 +       beos_inode_addr i_parent;
3615 +       beos_inode_addr i_attribute;
3616 +
3617 +       __u32   i_type;
3618 +
3619 +       union {
3620 +               beos_data_stream ds;
3621 +               char            symlink[BEOS_SYMLINK_LEN];
3622 +       } i_data;
3623 +};
3624 +
3625 +#endif /* _LINUX_BEOS_FS_I_ */
3626 diff -aur --new-file linux-2.2.18-pre2-clean/include/linux/beos_fs_sb.h linux-2.2.18-pre2-beos/include/linux/beos_fs_sb.h
3627 --- linux-2.2.18-pre2-clean/include/linux/beos_fs_sb.h  Wed Dec 31 18:00:00 1969
3628 +++ linux-2.2.18-pre2-beos/include/linux/beos_fs_sb.h   Sat Sep  2 12:26:30 2000
3629 @@ -0,0 +1,44 @@
3630 +/*
3631 + *  linux/include/linux/beos_fs_sb.h
3632 + *
3633 + * Copyright (C) 1999  Makoto Kato (m_kato@ga2.so-net.ne.jp)
3634 + */
3635 +
3636 +#ifndef _LINUX_BEOS_FS_SB
3637 +#define _LINUX_BEOS_FS_SB
3638 +
3639 +#include <linux/types.h>
3640 +#include <linux/beos_fs.h>
3641 +
3642 +
3643 +struct beos_sb_info {
3644 +       __u32           block_size;
3645 +       __u32           block_shift;
3646 +       beos_off_t      num_blocks;
3647 +       beos_off_t      used_blocks;
3648 +       __u32           inode_size;
3649 +
3650 +       /*
3651 +        * Allocation group information
3652 +        */
3653 +
3654 +       __u32   blocks_per_ag;
3655 +       __u32   ag_shift;
3656 +       __u32   num_ags;
3657 +
3658 +       /*
3659 +        * jornal log entry
3660 +        */
3661 +
3662 +       beos_block_run log_blocks;
3663 +       beos_off_t log_start;
3664 +       beos_off_t log_end;
3665 +
3666 +       beos_inode_addr root_dir;
3667 +       beos_inode_addr indices;
3668 +
3669 +       beos_mount_options mount_opts;
3670 +
3671 +       struct nls_table * nls;
3672 +};
3673 +#endif
3674 diff -aur --new-file linux-2.2.18-pre2-clean/include/linux/fs.h linux-2.2.18-pre2-beos/include/linux/fs.h
3675 --- linux-2.2.18-pre2-clean/include/linux/fs.h.orig     Mon Sep  4 20:57:21 2000
3676 +++ linux-2.2.18-pre2-clean/include/linux/fs.h  Mon Sep  4 21:01:43 2000
3677 @@ -280,6 +280,7 @@
3678  #include <linux/adfs_fs_i.h>
3679  #include <linux/qnx4_fs_i.h>
3680  #include <linux/usbdev_fs_i.h>
3681 +#include <linux/beos_fs_i.h>
3682
3683  /*
3684   * Attribute flags.  These should be or-ed together to figure out what
3685 @@ -395,6 +396,7 @@
3686                 struct qnx4_inode_info          qnx4_i;
3687                 struct usbdev_inode_info        usbdev_i;
3688                 struct socket                   socket_i;
3689 +               struct beos_inode_info          beos_i;
3690                 void                            *generic_ip;
3691         } u;
3692  };
3693 @@ -517,6 +519,7 @@
3694  #include <linux/adfs_fs_sb.h>
3695  #include <linux/qnx4_fs_sb.h>
3696  #include <linux/usbdev_fs_sb.h>
3697 +#include <linux/beos_fs_sb.h>
3698
3699  extern struct list_head super_blocks;
3700
3701 @@ -561,6 +564,7 @@
3702                 struct adfs_sb_info     adfs_sb;
3703                 struct qnx4_sb_info     qnx4_sb;
3704                 struct usbdev_sb_info   usbdevfs_sb;
3705 +               struct beos_sb_info     beos_sb;
3706                 void                    *generic_sbp;
3707         } u;
3708         /*