Script e sorgenti del kernel

  10001 #!/bin/sh
  10002 
  10003 bochs -q "boot:floppy" \
  10004          "floppya: 1_44=floppy.a, status=inserted" \
  10005          "floppyb: 1_44=floppy.b, status=inserted" \
  10006          "keyboard_mapping: enabled=1, \
  10007           map=/usr/share/bochs/keymaps/x11-pc-it.map" \
  10008          "keyboard_type: xt" \
  10009          "vga: none" \
  10010          "romimage: file=\"/usr/share/bochs/BIOS-bochs-legacy\"" \
  10011          "megs:1"

  20001 #!/bin/sh
  20002 
  20003 qemu -fda floppy.a \
  20004      -fdb floppy.b \
  20005      -boot order=a
  20006 

  30001 #!/bin/sh
  30002 #
  30003 # makeit...
  30004 #
  30005 OPTION="$1"
  30006 OS16PATH=""
  30007 #
  30008 edition () {
  30009     local EDITION="kernel/main/build.h"
  30010     echo -n                              > $EDITION
  30011     echo -n "#define BUILD_DATE \""     >> $EDITION
  30012     echo -n `date "+%Y.%m.%d %H:%M:%S"` >> $EDITION
  30013     echo  "\""                          >> $EDITION
  30014 }
  30015 #
  30016 #
  30017 #
  30018 makefile () {
  30019     #
  30020     local MAKEFILE="Makefile"
  30021     local TAB=" "
  30022     #
  30023     local SOURCE_C=""
  30024     local C=""
  30025     local SOURCE_S=""
  30026     local S=""
  30027     #
  30028     local c
  30029     local s
  30030     #
  30031     # Trova i file in C.
  30032     #
  30033     for c in *.c
  30034     do
  30035         if [ -f $c ]
  30036         then
  30037         C=`basename $c .c`
  30038             SOURCE_C="$SOURCE_C $C"
  30039         fi
  30040     done
  30041     #
  30042     # Trova i file in ASM.
  30043     #
  30044     for s in *.s
  30045     do
  30046         if [ -f $s ]
  30047         then
  30048         S=`basename $s .s`
  30049             SOURCE_S="$SOURCE_S $S"
  30050         fi
  30051     done
  30052     #
  30053     # Prepara il file make.
  30054     # GCC viene usato per potenziare il controllo degli errori.
  30055     #
  30056     echo -n                                                  > $MAKEFILE
  30057     echo "# This file was made automatically"               >> $MAKEFILE
  30058     echo "# by the script \`makeit\', based on the"         >> $MAKEFILE
  30059     echo "# directory content."                             >> $MAKEFILE
  30060     echo "# Please use \`makeit\' to compile and"           >> $MAKEFILE
  30061     echo "# \`makeit clean\' to clean directories."         >> $MAKEFILE
  30062     echo "#"                                                >> $MAKEFILE
  30063     echo "c = $SOURCE_C"                                    >> $MAKEFILE
  30064     echo "#"                                                >> $MAKEFILE
  30065     echo "s = $SOURCE_S"                                    >> $MAKEFILE
  30066     echo "#"                                                >> $MAKEFILE
  30067     echo "all: \$(s) \$(c)"                                 >> $MAKEFILE
  30068     echo "#"                                                >> $MAKEFILE
  30069     echo "clean:"                                           >> $MAKEFILE
  30070     echo "${TAB}@rm \$(c) \$(s) *.o *.assembler 2> /dev/null ; true" \
  30071                                                             >> $MAKEFILE
  30072     echo "${TAB}@rm *.symbols 2> /dev/null     ; true"      >> $MAKEFILE
  30073     echo "${TAB}@pwd"                                       >> $MAKEFILE
  30074     echo "#"                                                >> $MAKEFILE
  30075     echo "\$(c):"                                           >> $MAKEFILE
  30076     echo "${TAB}@echo \$@.c"                                >> $MAKEFILE
  30077     echo "${TAB}@gcc -Wall -c -o \$@.o " \
  30078                        "-I " \
  30079                        "-I. " \
  30080                        "-I$OS16PATH/lib " \
  30081                        "-I$OS16PATH/ " \
  30082                        "\$@.c"                              >> $MAKEFILE
  30083     echo "${TAB}@rm \$@.o"                                  >> $MAKEFILE
  30084     echo "${TAB}@bcc -ansi -0 -Mc -S -o \$@.assembler " \
  30085                        "-I " \
  30086                        "-I. " \
  30087                        "-I$OS16PATH/lib " \
  30088                        "-I$OS16PATH/ " \
  30089                        "\$@.c"                              >> $MAKEFILE
  30090     echo "${TAB}@bcc -ansi -0 -Mc -c -o \$@.o " \
  30091                        "-I " \
  30092                        "-I. " \
  30093                        "-I$OS16PATH/lib " \
  30094                        "-I$OS16PATH/ " \
  30095                        "\$@.c"                              >> $MAKEFILE
  30096     echo "#"                                                >> $MAKEFILE
  30097     echo "\$(s):"                                           >> $MAKEFILE
  30098     echo "${TAB}@echo \$@.s"                                >> $MAKEFILE
  30099     echo "${TAB}@as86 -u -0 -o \$@.o -s \$@.symbols \$@.s"  >> $MAKEFILE
  30100     #
  30101 }
  30102 #
  30103 #
  30104 #
  30105 main () {
  30106     #
  30107     local CURDIR=`pwd`
  30108     local OBJECTS
  30109     local OBJLIB
  30110     local EXEC
  30111     local BASENAME
  30112     local PROGNAME
  30113     local d
  30114     local c
  30115     local s
  30116     local o
  30117     #
  30118     edition
  30119     #
  30120     # Copia dello scheletro
  30121     #
  30122     if [ "$OPTION" = "clean" ]
  30123     then
  30124         #
  30125         # La copia non va fatta.
  30126         #
  30127         true
  30128     else
  30129         cp -dpRv skel/etc   /mnt/os16.a/
  30130         cp -dpRv skel/dev   /mnt/os16.a/
  30131         mkdir               /mnt/os16.a/mnt/
  30132         mkdir               /mnt/os16.a/tmp/
  30133         chmod 0777          /mnt/os16.a/tmp/
  30134         mkdir               /mnt/os16.a/usr/
  30135         cp -dpRv skel/root  /mnt/os16.a/
  30136         cp -dpRv skel/home  /mnt/os16.a/
  30137         cp -dpRv skel/usr/* /mnt/os16.b/
  30138     fi
  30139     #
  30140     #
  30141     #
  30142     for d in `find kernel`  \
  30143              `find lib`     \
  30144              `find applic`  \
  30145              `find ported`
  30146     do
  30147         if [ -d "$d" ]
  30148         then
  30149             #
  30150             # Sono presenti dei file C o ASM?
  30151             #
  30152             c=`echo $d/*.c | sed "s/ .*//"`
  30153             s=`echo $d/*.s | sed "s/ .*//"`
  30154             #
  30155             if [ -f "$c" ] || [ -f "$s" ]
  30156             then
  30157                 #
  30158                 # Sì
  30159                 #
  30160                 CURDIR=`pwd`
  30161                 cd $d
  30162                 #
  30163                 # Ricrea il file make
  30164                 #
  30165                 makefile
  30166                 #
  30167                 # Pulisce quindi la directory
  30168                 #
  30169                 make clean
  30170                 #
  30171                 #
  30172                 #
  30173                 if [ "$OPTION" = "clean" ]
  30174                 then
  30175                     #
  30176                     # È stata richiesta la pulitura, ma questa
  30177                     # è appena stata fatta!
  30178                     #
  30179                     true
  30180                 else
  30181                     #
  30182                     # Qualunque altro argomento viene considerato
  30183                     # un `make'.
  30184                     #
  30185                     if ! make
  30186                     then
  30187                         #
  30188                         # La compilazione è fallita.
  30189                         #
  30190                         cd "$CURDIR"
  30191                         exit
  30192                     fi
  30193                 fi
  30194                 cd "$CURDIR"
  30195             fi
  30196         fi
  30197     done
  30198     #
  30199     cd "$CURDIR"
  30200     #
  30201     # Link
  30202     #
  30203     if [ "$OPTION" = "clean" ]
  30204     then
  30205         #
  30206         # Il collegamento non va fatto.
  30207         #
  30208         true
  30209     else
  30210         #
  30211         # Collegamento dei file del kernel.
  30212         #
  30213         OBJECTS=""
  30214         #
  30215         for o in `find kernel   -name \*.o -print` \
  30216                  `find lib      -name \*.o -print`
  30217         do
  30218             if    [ "$o" = "./kernel/main/crt0.o" ] \
  30219                || [ "$o" = "./kernel/main/main.o" ] \
  30220                || [ ! -e "$o" ]
  30221             then
  30222                 true
  30223             else
  30224                 OBJECTS="$OBJECTS $o"
  30225             fi
  30226         done
  30227         #
  30228         echo "Link"
  30229         #
  30230         ld86 -i -d -s -m -o kimage    \
  30231                 kernel/main/crt0.o    \
  30232                 kernel/main/main.o    \
  30233                 $OBJECTS
  30234         #
  30235         # Copia il kernel nel dischetto.
  30236         #
  30237         if mount | grep /mnt/os16.a > /dev/null
  30238         then
  30239             cp -f kimage /mnt/os16.a/boot
  30240         else
  30241             echo "[$0] Cannot copy the kernel image "
  30242             echo "[$0]   inside the floppy disk image!"
  30243         fi
  30244         sync
  30245         #
  30246         # Collegamento delle applicazioni di os16.
  30247         #
  30248         OBJLIB=""
  30249         #
  30250         for o in `find lib      -name \*.o -print`
  30251         do
  30252             OBJLIB="$OBJLIB $o"
  30253         done
  30254         #
  30255         # Scansione delle applicazioni interne.
  30256         #
  30257         for o in `find applic     -name \*.o -print`
  30258         do
  30259             if    [ "$o" = "applic/crt0.o" ] \
  30260                || [ ! -e "$o" ] \
  30261                || echo "$o" | grep ".crt0.o$" > /dev/null
  30262             then
  30263                 #
  30264                 # Il file non esiste oppure si tratta di `...crt0.s'.
  30265                 #
  30266                 true
  30267             else
  30268                 #
  30269                 # File oggetto differente da `...crt0.s'.
  30270                 #
  30271                 EXEC=`echo "$o" | sed "s/\.o$//"`
  30272                 BASENAME=`basename $o .o`
  30273                 if [ -e "applic/$BASENAME.crt0.o" ]
  30274                 then
  30275                     #
  30276                     # Qui c'è un file `...crt0.o' specifico.
  30277                     #
  30278                     ld86 -i -d -s -o $EXEC \
  30279                          applic/$BASENAME.crt0.o $o $OBJLIB
  30280                 else
  30281                     #
  30282                     # Qui si usa il file `crt0.o' generale.
  30283                     #
  30284                     ld86 -i -d -s -o $EXEC applic/crt0.o $o $OBJLIB
  30285                 fi
  30286                 #
  30287                 if [ -x "applic/$BASENAME" ]
  30288                 then
  30289                     if mount | grep /mnt/os16.a > /dev/null
  30290                     then
  30291                         mkdir /mnt/os16.a/bin/ 2> /dev/null
  30292                         cp -f "$EXEC" /mnt/os16.a/bin
  30293                     else
  30294                         echo "[$0] Cannot copy the application "
  30295                         echo "[$0]   $BASENAME inside the floppy "
  30296                         echo "[$0]   disk image!"
  30297                         break
  30298                     fi
  30299                 fi
  30300             fi
  30301         done
  30302         sync
  30303         #
  30304         # Collegamento delle applicazioni più semplici,
  30305         # provenienti da altri sistemi operativi.
  30306         #
  30307         for o in `find ported/mix -name \*.o -print`
  30308         do
  30309             if    [ "$o" = "ported/mix/crt0.o" ] \
  30310                || [ ! -e "$o" ] \
  30311                || echo "$o" | grep ".crt0.o$" > /dev/null
  30312             then
  30313                 #
  30314                 # Il file non esiste oppure si tratta di `...crt0.s'.
  30315                 #
  30316                 true
  30317             else
  30318                 #
  30319                 # File oggetto differente da `...crt0.s'.
  30320                 #
  30321                 EXEC=`echo "$o" | sed "s/\.o$//"`
  30322                 BASENAME=`basename $o .o`
  30323                 if [ -e "ported/mix/$BASENAME.crt0.o" ]
  30324                 then
  30325                     #
  30326                     # Qui c'è un file `...crt0.o' specifico.
  30327                     #
  30328                     ld86 -i -d -s -o $EXEC \
  30329                          applic/$BASENAME.crt0.o $o $OBJLIB
  30330                 else
  30331                     #
  30332                     # Qui si usa il file `crt0.o' generale.
  30333                     #
  30334                     ld86 -i -d -s -o $EXEC applic/crt0.o $o $OBJLIB
  30335                 fi
  30336                 #
  30337                 if [ -x "$EXEC" ]
  30338                 then
  30339                     if mount | grep /mnt/os16.a > /dev/null
  30340                     then
  30341                         mkdir /mnt/os16.b/bin/ 2> /dev/null
  30342                         cp -f "$EXEC" /mnt/os16.b/bin
  30343                     else
  30344                         echo "[$0] Cannot copy the application "
  30345                         echo "[$0]   $EXEC inside the floppy "
  30346                         echo "[$0]   disk image!"
  30347                         break
  30348                     fi
  30349                 fi
  30350             fi
  30351         done
  30352         sync
  30353         #
  30354         # Altre applicazioni più importanti.
  30355         #
  30356         for d in ported/*
  30357         do
  30358             if [ -d "$d" ]
  30359             then
  30360                 #
  30361                 #
  30362                 #
  30363                 OBJECTS=""
  30364                 BASENAME=`basename $d`
  30365                 EXEC="$d/$BASENAME"
  30366                 #
  30367                 #
  30368                 #
  30369                 if [ "$BASENAME" = "mix" ]
  30370                 then
  30371                     #
  30372                     # già fatto.
  30373                     #
  30374                     continue
  30375                 fi
  30376                 #
  30377                 #
  30378                 #
  30379                 for o in $d/*.o
  30380                 do
  30381                     if    [ "$o" = "$d/crt0.o" ] \
  30382                        || [ ! -e "$o" ]
  30383                     then
  30384                         true
  30385                     else
  30386                         OBJECTS="$OBJECTS $o"
  30387                     fi
  30388                 done
  30389                 #
  30390                 ld86 -i -d -s -o $EXEC $d/crt0.o $OBJECTS $OBJLIB
  30391                 #
  30392                 if [ -x "$d/$BASENAME" ]
  30393                 then
  30394                     if mount | grep /mnt/os16.b > /dev/null
  30395                     then
  30396                         mkdir /mnt/os16.b/bin/ 2> /dev/null
  30397                         cp -f "$EXEC" /mnt/os16.b/bin
  30398                     else
  30399                         echo "[$0] Cannot copy the application "
  30400                         echo "[$0]   $BASENAME inside the floppy "
  30401                         echo "[$0]   disk image!"
  30402                         break
  30403                     fi
  30404                 fi
  30405             fi
  30406         done
  30407         sync
  30408 
  30409     fi
  30410 }
  30411 #
  30412 # Start.
  30413 #
  30414 if [ -d kernel ]   && \
  30415    [ -d applic ]   && \
  30416    [ -d lib  ]
  30417 then
  30418     OS16PATH=`pwd`
  30419     main
  30420 else
  30421     echo "[$0] Running from a wrong directory!"
  30422 fi

  40001 #ifndef _KERNEL_DEVICES_H
  40002 #define _KERNEL_DEVICES_H 1
  40003 
  40004 #include <sys/os16.h>
  40005 #include <sys/types.h>
  40006 //----------------------------------------------------------------------
  40007 #define DEV_READ                0
  40008 #define DEV_WRITE               1
  40009 ssize_t dev_io    (pid_t pid, dev_t device, int rw, off_t offset,
  40010                    void *buffer, size_t size, int *eof);
  40011 //----------------------------------------------------------------------
  40012 // The following functions are used only by `dev_io()'.
  40013 //----------------------------------------------------------------------
  40014 ssize_t dev_mem   (pid_t pid, dev_t device, int rw, off_t offset,
  40015                    void *buffer, size_t size, int *eof);
  40016 ssize_t dev_tty   (pid_t pid, dev_t device, int rw, off_t offset,
  40017                    void *buffer, size_t size, int *eof);
  40018 ssize_t dev_dsk   (pid_t pid, dev_t device, int rw, off_t offset,
  40019                    void *buffer, size_t size, int *eof);
  40020 ssize_t dev_kmem  (pid_t pid, dev_t device, int rw, off_t offset,
  40021                    void *buffer, size_t size, int *eof);
  40022 //----------------------------------------------------------------------
  40023 
  40024 #endif

  50001 #include <sys/os16.h>
  50002 #include <kernel/devices.h>
  50003 #include <sys/types.h>
  50004 #include <errno.h>
  50005 #include <kernel/memory.h>
  50006 #include <kernel/ibm_i86.h>
  50007 #include <kernel/proc.h>
  50008 #include <string.h>
  50009 #include <signal.h>
  50010 #include <kernel/k_libc.h>
  50011 #include <ctype.h>
  50012 #include <kernel/tty.h>
  50013 //----------------------------------------------------------------------
  50014 ssize_t
  50015 dev_dsk (pid_t pid, dev_t device, int rw, off_t offset, void *buffer,
  50016          size_t size, int *eof)
  50017 {
  50018     ssize_t n;
  50019     int     dev_minor = minor (device);
  50020 
  50021     if (rw == DEV_READ)
  50022       {
  50023         n = dsk_read_bytes (dev_minor, offset, buffer, size);
  50024       }
  50025     else
  50026       {
  50027         n = dsk_write_bytes (dev_minor, offset, buffer, size);
  50028       }
  50029     return (n);
  50030 }

  60001 #include <sys/os16.h>
  60002 #include <kernel/devices.h>
  60003 #include <sys/types.h>
  60004 #include <errno.h>
  60005 #include <kernel/memory.h>
  60006 #include <kernel/ibm_i86.h>
  60007 #include <kernel/proc.h>
  60008 #include <string.h>
  60009 #include <signal.h>
  60010 #include <kernel/k_libc.h>
  60011 #include <ctype.h>
  60012 #include <kernel/tty.h>
  60013 //----------------------------------------------------------------------
  60014 ssize_t
  60015 dev_io (pid_t pid, dev_t device, int rw, off_t offset,
  60016         void *buffer, size_t size, int *eof)
  60017 {
  60018     int dev_major = major (device);
  60019     if (rw != DEV_READ && rw != DEV_WRITE)
  60020       {
  60021         errset (EIO);
  60022         return (-1);
  60023       }
  60024     switch (dev_major)
  60025       {
  60026         case DEV_MEM_MAJOR:
  60027             return (dev_mem (pid, device, rw, offset, buffer, size,
  60028                              eof));
  60029         case DEV_TTY_MAJOR:
  60030             return (dev_tty (pid, device, rw, offset, buffer, size,
  60031                              eof));
  60032         case DEV_CONSOLE_MAJOR:
  60033             return (dev_tty (pid, device, rw, offset, buffer, size,
  60034                              eof));
  60035         case DEV_DSK_MAJOR:
  60036             return (dev_dsk (pid, device, rw, offset, buffer, size,
  60037                              eof));
  60038         case DEV_KMEM_MAJOR:
  60039             return (dev_kmem (pid, device, rw, offset, buffer, size,
  60040                               eof));
  60041         default:
  60042             errset (ENODEV);
  60043             return (-1);
  60044       }
  60045 }

  70001 #include <sys/os16.h>
  70002 #include <kernel/devices.h>
  70003 #include <sys/types.h>
  70004 #include <errno.h>
  70005 #include <kernel/memory.h>
  70006 #include <kernel/ibm_i86.h>
  70007 #include <kernel/proc.h>
  70008 #include <string.h>
  70009 #include <signal.h>
  70010 #include <kernel/k_libc.h>
  70011 #include <ctype.h>
  70012 #include <kernel/tty.h>
  70013 //----------------------------------------------------------------------
  70014 ssize_t
  70015 dev_kmem (pid_t pid, dev_t device, int rw, off_t offset, void *buffer,
  70016           size_t size, int *eof)
  70017 {
  70018   size_t    size_real;
  70019   inode_t  *inode;
  70020   sb_t     *sb;
  70021   file_t   *file;
  70022   void     *start;
  70023   //
  70024   // Only read is allowed.
  70025   //
  70026   if (rw != DEV_READ)
  70027     {
  70028       errset (EIO);                           // I/O error.
  70029       return ((ssize_t) -1);
  70030     }
  70031   //
  70032   // Only positive offset is allowed.
  70033   //
  70034   if (offset < 0)
  70035     {
  70036       errset (EIO);                           // I/O error.
  70037       return ((ssize_t) -1);
  70038     }
  70039   //
  70040   // Read is selected (and is the only access allowed).
  70041   //
  70042   switch (device)
  70043     {
  70044       case DEV_KMEM_PS:
  70045           //
  70046           // Verify if the selected slot can be read.
  70047           //
  70048           if (offset >= PROCESS_MAX)
  70049             {
  70050               errset (EIO);                   // I/O error.
  70051               return ((ssize_t) -1);
  70052             }
  70053           //
  70054           // Correct the size to be read.
  70055           //
  70056           if (sizeof (proc_t) < size)
  70057             {
  70058               size = sizeof (proc_t);
  70059             }
  70060           //  //
  70061           //  // Correct the size to be read.
  70062           //  //
  70063           //  size_real = ((sizeof (proc_t)) * (PROCESS_MAX - offset));
  70064           //  if (size_real < size)
  70065           //    {
  70066           //      size = size_real;
  70067           //    }
  70068           //
  70069           // Get the pointer to the selected slot.
  70070           //
  70071           start = proc_reference ((pid_t) offset);
  70072           break;
  70073       case DEV_KMEM_MMP:
  70074           //
  70075           // Correct the size to be read.
  70076           //
  70077           size_real = (MEM_MAX_BLOCKS/8);
  70078           if (size_real < size)
  70079             {
  70080               size = size_real;
  70081             }
  70082           //
  70083           // Get the pointer to the map.
  70084           //
  70085           start = mb_reference ();
  70086           break;
  70087       case DEV_KMEM_SB:
  70088           //
  70089           // Get a reference to the super block table.
  70090           //
  70091           sb = sb_reference (0);
  70092           //
  70093           // Correct the size to be read.
  70094           //
  70095           if (sizeof (sb_t) < size)
  70096             {
  70097               size = sizeof (sb_t);
  70098             }
  70099           //
  70100           // Get the pointer to the selected super block slot.
  70101           //
  70102           start = &sb[offset];
  70103           break;
  70104       case DEV_KMEM_INODE:
  70105           //
  70106           // Get a reference to the inode table.
  70107           //
  70108           inode = inode_reference (0, 0);
  70109           //
  70110           // Correct the size to be read.
  70111           //
  70112           if (sizeof (inode_t) < size)
  70113             {
  70114               size = sizeof (inode_t);
  70115             }
  70116           //
  70117           // Get the pointer to the selected inode slot.
  70118           //
  70119           start = &inode[offset];
  70120           break;
  70121       case DEV_KMEM_FILE:
  70122           //
  70123           // Get a reference to the file table.
  70124           //
  70125           file = file_reference (0);
  70126           //
  70127           // Correct the size to be read.
  70128           //
  70129           if (sizeof (file_t) < size)
  70130             {
  70131               size = sizeof (file_t);
  70132             }
  70133           //
  70134           // Get the pointer to the selected inode slot.
  70135           //
  70136           start = &file[offset];
  70137           break;
  70138       default:
  70139           errset (ENODEV);            // No such device.
  70140           return ((ssize_t) -1);
  70141     }
  70142   //
  70143   // At this point, data is ready to be copied to the buffer.
  70144   //
  70145   memcpy (buffer, start, size);
  70146   //
  70147   // Return size read.
  70148   //
  70149   return (size);
  70150 }

  80001 #include <sys/os16.h>
  80002 #include <kernel/devices.h>
  80003 #include <sys/types.h>
  80004 #include <errno.h>
  80005 #include <kernel/memory.h>
  80006 #include <kernel/ibm_i86.h>
  80007 #include <kernel/proc.h>
  80008 #include <string.h>
  80009 #include <signal.h>
  80010 #include <kernel/k_libc.h>
  80011 #include <ctype.h>
  80012 #include <kernel/tty.h>
  80013 //----------------------------------------------------------------------
  80014 ssize_t
  80015 dev_mem (pid_t pid, dev_t device, int rw, off_t offset, void *buffer,
  80016          size_t size, int *eof)
  80017 {
  80018     uint8_t  *buffer08 = (uint8_t *) buffer;
  80019     uint16_t *buffer16 = (uint16_t *) buffer;
  80020     ssize_t n;
  80021 
  80022     if      (device == DEV_MEM)                         // DEV_MEM
  80023       {
  80024         if (rw == DEV_READ)
  80025           {
  80026             n = mem_read ((addr_t) offset, buffer, size);
  80027           }
  80028         else
  80029           {
  80030             n = mem_write ((addr_t) offset, buffer, size);
  80031           }
  80032       }
  80033     else if (device == DEV_NULL)                        // DEV_NULL
  80034       {
  80035         n = 0;
  80036       }
  80037     else if (device == DEV_ZERO)                        // DEV_ZERO
  80038       {
  80039         if (rw == DEV_READ)
  80040           {
  80041             for (n = 0; n < size; n++)
  80042               {
  80043                 buffer08[n] = 0;
  80044               }
  80045           }
  80046         else
  80047           {
  80048             n = 0;
  80049           }
  80050       }
  80051     else if (device == DEV_PORT)                        // DEV_PORT
  80052       {
  80053         if (rw == DEV_READ)
  80054           {
  80055             if (size == 1)
  80056               {
  80057                 buffer08[0] = in_8 (offset);
  80058                 n = 1;
  80059               }
  80060             else if (size == 2)
  80061               {
  80062                 buffer16[0] = in_16 (offset);
  80063                 n = 2;
  80064               }
  80065             else
  80066               {
  80067                 n = 0;
  80068               }
  80069           }
  80070         else
  80071           {
  80072             if (size == 1)
  80073               {
  80074                 out_8 (offset, buffer08[0]);
  80075               }
  80076             else if (size == 2)
  80077               {
  80078                 out_16 (offset, buffer16[0]);
  80079                 n = 2;
  80080               }
  80081             else
  80082               {
  80083                 n = 0;
  80084               }
  80085           }
  80086       }
  80087     else
  80088       {
  80089         errset (ENODEV);
  80090         return (-1);
  80091       }
  80092     return (n);
  80093 }

  90001 #include <sys/os16.h>
  90002 #include <kernel/devices.h>
  90003 #include <sys/types.h>
  90004 #include <errno.h>
  90005 #include <kernel/memory.h>
  90006 #include <kernel/ibm_i86.h>
  90007 #include <kernel/proc.h>
  90008 #include <string.h>
  90009 #include <signal.h>
  90010 #include <kernel/k_libc.h>
  90011 #include <ctype.h>
  90012 #include <kernel/tty.h>
  90013 //----------------------------------------------------------------------
  90014 ssize_t
  90015 dev_tty (pid_t pid, dev_t device, int rw, off_t offset, void *buffer,
  90016          size_t size, int *eof)
  90017 {
  90018     uint8_t *buffer08 = (uint8_t *) buffer;
  90019     ssize_t  n;
  90020     proc_t  *ps;
  90021     //
  90022     // Get process. Variable `ps' will be `NULL' if the process ID is
  90023     // not valid.
  90024     //
  90025     ps = proc_reference (pid);
  90026     //
  90027     // Convert `DEV_TTY' with the controlling terminal for the process.
  90028     //
  90029     if (device == DEV_TTY)
  90030       {
  90031         device = ps->device_tty;
  90032         //
  90033         // As a last resort, use the generic `DEV_CONSOLE'.
  90034         //
  90035         if (device == 0 || device == DEV_TTY)
  90036           {
  90037             device = DEV_CONSOLE;
  90038           }
  90039       }
  90040     //
  90041     // Convert `DEV_CONSOLE' to the currently active console.
  90042     //
  90043     if (device == DEV_CONSOLE)
  90044       {
  90045         device = tty_console ((dev_t) 0);
  90046         //
  90047         // As a last resort, use the first console: `DEV_CONSOLE0'.
  90048         //
  90049         if (device == 0 || device == DEV_TTY)
  90050           {
  90051             device = DEV_CONSOLE0;
  90052           }
  90053       }
  90054     //
  90055     // Read or write.
  90056     //
  90057     if (rw == DEV_READ)
  90058       {
  90059         for (n = 0; n < size; n++)
  90060           {
  90061             buffer08[n] = tty_read (device);
  90062             if (buffer08[n] == 0)
  90063               {
  90064                 //
  90065                 // If the pid is not the kernel, should put the process
  90066                 // to sleep, waiting for the key.
  90067                 //
  90068                 if (pid == 0 || ps == NULL)
  90069                   {
  90070                     //
  90071                     // For the kernel there is no sleep and for an
  90072                     // unidentified process, either.
  90073                     //
  90074                     break;
  90075                   }
  90076                 //
  90077                 // Put the process to sleep.
  90078                 //
  90079                 ps->status         = PROC_SLEEPING;
  90080                 ps->ret            = 0;
  90081                 ps->wakeup_events  = WAKEUP_EVENT_TTY;
  90082                 ps->wakeup_signal  = 0;
  90083                 ps->wakeup_timer   = 0;
  90084                 //
  90085                 break;
  90086               }
  90087             //
  90088             // Check for control characters.
  90089             //
  90090             if (buffer08[n] == 0x04)    // EOT
  90091               {
  90092                 //
  90093                 // Return EOF.
  90094                 //
  90095                 *eof = 1;
  90096                 break;
  90097               }
  90098             //
  90099             // At this point, show the character on screen, even if it
  90100             // is not nice. It is necessary to show something, because
  90101             // the tty handling is very poor and the library for line
  90102             // input, calculate cursor position based on the characters
  90103             // received.
  90104             //
  90105             tty_write (device, (int) buffer08[n]);
  90106           }
  90107       }
  90108     else
  90109       {
  90110         for (n = 0; n < size; n++)
  90111           {
  90112             tty_write (device, (int) buffer08[n]);
  90113           }
  90114       }
  90115     return (n);
  90116 }

 100001 #ifndef _KERNEL_DIAG_H
 100002 #define _KERNEL_DIAG_H 1
 100003 
 100004 #include <stdint.h>
 100005 #include <kernel/fs.h>
 100006 #include <sys/types.h>
 100007 #include <kernel/proc.h>
 100008 
 100009 //----------------------------------------------------------------------
 100010 uint8_t  reverse_8_bit  (uint8_t  source);
 100011 uint16_t reverse_16_bit (uint16_t source);
 100012 uint32_t reverse_32_bit (uint32_t source);
 100013 
 100014 #define reverse_char(s)      ((char)     reverse_8_bit  ((uint8_t)  s))
 100015 #define reverse_short(s)     ((short)    reverse_16_bit ((uint16_t) s))
 100016 #define reverse_int(s)       ((int)      reverse_16_bit ((uint16_t) s))
 100017 #define reverse_long(s)      ((long)     reverse_32_bit ((uint32_t) s))
 100018 #define reverse_long_int(s)  ((long int) reverse_32_bit ((uint32_t) s))
 100019 //----------------------------------------------------------------------
 100020 void print_hex_8  (void *data, size_t elements);
 100021 void print_hex_16 (void *data, size_t elements);
 100022 void print_hex_32 (void *data, size_t elements);
 100023 
 100024 #define print_hex_char(d, e)      (print_hex_8  (d, e))
 100025 #define print_hex_short(d, e)     (print_hex_16 (d, e))
 100026 #define print_hex_int(d, e)       (print_hex_16 (d, e))
 100027 #define print_hex_long(d, e)      (print_hex_32 (d, e))
 100028 #define print_hex_long_int(d, e)  (print_hex_32 (d, e))
 100029 //----------------------------------------------------------------------
 100030 void print_hex_8_reverse  (void *data, size_t elements);
 100031 void print_hex_16_reverse (void *data, size_t elements);
 100032 void print_hex_32_reverse (void *data, size_t elements);
 100033 
 100034 #define print_hex_char_reverse(d, e)      (print_hex_8_reverse  (d, e))
 100035 #define print_hex_short_reverse(d, e)     (print_hex_16_reverse (d, e))
 100036 #define print_hex_int_reverse(d, e)       (print_hex_16_reverse (d, e))
 100037 #define print_hex_long_reverse(d, e)      (print_hex_32_reverse (d, e))
 100038 #define print_hex_long_int_reverse(d, e)  (print_hex_32_reverse (d, e))
 100039 //----------------------------------------------------------------------
 100040 void print_segments (void);
 100041 void print_kmem     (void);
 100042 //----------------------------------------------------------------------
 100043 void print_mb_map     (void);
 100044 void print_memory_map (void);
 100045 //----------------------------------------------------------------------
 100046 void print_superblock       (sb_t *sb);
 100047 void print_inode            (inode_t *inode);
 100048 void print_inode_map        (sb_t *sb, uint16_t *bitmap);
 100049 void print_zone_map         (sb_t *sb, uint16_t *bitmap);
 100050 void print_inode_head       (void);
 100051 void print_inode_list       (void);
 100052 void print_inode_zones_head (void);
 100053 void print_inode_zones      (inode_t *inode);
 100054 void print_inode_zones_list (void);
 100055 //----------------------------------------------------------------------
 100056 void print_proc_head (void);
 100057 void print_proc_pid  (proc_t *ps, pid_t pid);
 100058 void print_proc_list (void);
 100059 //----------------------------------------------------------------------
 100060 void print_file_head (void);
 100061 void print_file_num  (int num);
 100062 void print_file_list (void);
 100063 //----------------------------------------------------------------------
 100064 void print_fd_head (void);
 100065 void print_fd      (fd_t *fd);
 100066 void print_fd_list (pid_t pid);
 100067 //----------------------------------------------------------------------
 100068 void print_time      (void);
 100069 //----------------------------------------------------------------------
 100070 
 100071 #endif

 110001 #include <sys/os16.h>
 110002 #include <kernel/diag.h>
 110003 #include <kernel/k_libc.h>
 110004 #include <fcntl.h>
 110005 //----------------------------------------------------------------------
 110006 void
 110007 print_fd (fd_t *fd)
 110008 {
 110009     k_printf ("%04x %6li %3i %c/%c %05o %5i %3i %5li %4i %04x %3i",
 110010         (unsigned int)      fd->fl_flags,
 110011         (unsigned long int) fd->file->offset,
 110012         (unsigned int)      fd->file->references,
 110013         (fd->file->oflags & O_RDONLY ? 'r' : ' '),
 110014         (fd->file->oflags & O_WRONLY ? 'w' : ' '),
 110015         (unsigned int)      fd->file->inode->mode,
 110016         (unsigned int)      fd->file->inode->uid,
 110017         (unsigned int)      fd->file->inode->gid,
 110018         (unsigned long int) fd->file->inode->size,
 110019         (unsigned int)      fd->file->inode->links,
 110020         (unsigned int)      fd->file->inode->sb->device,
 110021         (unsigned int)      fd->file->inode->ino);
 110022     k_printf ("\n");
 110023 }

 120001 #include <sys/os16.h>
 120002 #include <kernel/diag.h>
 120003 #include <kernel/k_libc.h>
 120004 //----------------------------------------------------------------------
 120005 void
 120006 print_fd_head (void)
 120007 {
 120008 
 120009     k_printf ("n. stat offset ref flg  mode   uid gid  size lnks  ");
 120010     k_printf ("dev ino\n");
 120011 }

 130001 #include <sys/os16.h>
 130002 #include <kernel/diag.h>
 130003 #include <kernel/k_libc.h>
 130004 //----------------------------------------------------------------------
 130005 void
 130006 print_fd_list (pid_t pid)
 130007 {
 130008     int      fdn = 0;
 130009     fd_t *fd;
 130010     fd = fd_reference (pid, &fdn);
 130011     print_fd_head ();
 130012     for (fdn = 0; fdn < OPEN_MAX; fdn++)
 130013       {
 130014         if (fd[fdn].file != NULL)
 130015           {
 130016             k_printf ("%2i ", fdn);
 130017             print_fd (fd);
 130018           }
 130019       }
 130020 }

 140001 #include <sys/os16.h>
 140002 #include <kernel/diag.h>
 140003 #include <kernel/k_libc.h>
 140004 //----------------------------------------------------------------------
 140005 void
 140006 print_file_head (void)
 140007 {
 140008 
 140009     k_printf ("n. ref flg  mode uid  size lnks  dev ino\n");
 140010 }

 150001 #include <sys/os16.h>
 150002 #include <kernel/diag.h>
 150003 #include <kernel/k_libc.h>
 150004 //----------------------------------------------------------------------
 150005 void
 150006 print_file_list (void)
 150007 {
 150008     int     fno;
 150009     file_t *file = file_reference (0);
 150010     //
 150011     print_file_head ();
 150012     //
 150013     for (fno = 0; fno < FILE_MAX_SLOTS; fno++)
 150014       {
 150015         if (file[fno].references > 0)
 150016           {
 150017             print_file_num (fno);
 150018           }
 150019       }
 150020 }

 160001 #include <sys/os16.h>
 160002 #include <kernel/diag.h>
 160003 #include <kernel/k_libc.h>
 160004 #include <fcntl.h>
 160005 //----------------------------------------------------------------------
 160006 void
 160007 print_file_num (int fno)
 160008 {
 160009     file_t *file = file_reference (fno);
 160010 
 160011     k_printf ("%2i %3i %c/%c %05o %3i %5li %4i %04x %3i",
 160012               (unsigned int)      fno,
 160013               (unsigned int)      file->references,
 160014               (file->oflags & O_RDONLY ? 'r' : ' '),
 160015               (file->oflags & O_WRONLY ? 'w' : ' '),
 160016               (unsigned int)      file->inode->mode,
 160017               (unsigned int)      file->inode->uid,
 160018               (unsigned long int) file->inode->size,
 160019               (unsigned int)      file->inode->links,
 160020               (unsigned int)      file->inode->sb->device,
 160021               (unsigned int)      file->inode->ino);
 160022     k_printf ("\n");
 160023 }

 170001 #include <sys/os16.h>
 170002 #include <kernel/diag.h>
 170003 #include <kernel/k_libc.h>
 170004 #include <inttypes.h>
 170005 #include <stdio.h>
 170006 //----------------------------------------------------------------------
 170007 void
 170008 print_hex_16 (void *data, size_t elements)
 170009 {
 170010     uint16_t *element = (uint16_t *) data;
 170011     int i;
 170012     for (i = 0; i < elements; i++)
 170013       {
 170014         k_printf ("%04" PRIx16, (uint16_t) element[i]);
 170015       }
 170016 }

 180001 #include <sys/os16.h>
 180002 #include <kernel/diag.h>
 180003 #include <kernel/k_libc.h>
 180004 #include <inttypes.h>
 180005 #include <stdio.h>
 180006 //----------------------------------------------------------------------
 180007 void
 180008 print_hex_16_reverse (void *data, size_t elements)
 180009 {
 180010     uint16_t *element = (uint16_t *) data;
 180011     int i;
 180012     for (i = 0; i < elements; i++)
 180013       {
 180014         k_printf ("%04" PRIx16, reverse_16_bit (element[i]));
 180015       }
 180016 }

 190001 #include <sys/os16.h>
 190002 #include <kernel/diag.h>
 190003 #include <kernel/k_libc.h>
 190004 #include <inttypes.h>
 190005 #include <stdio.h>
 190006 //----------------------------------------------------------------------
 190007 void
 190008 print_hex_32 (void *data, size_t elements)
 190009 {
 190010     uint32_t *element = (uint32_t *) data;
 190011     int i;
 190012     for (i = 0; i < elements; i++)
 190013       {
 190014         k_printf ("%08" PRIx32, (uint32_t) element[i]);
 190015       }
 190016 }

 200001 #include <sys/os16.h>
 200002 #include <kernel/diag.h>
 200003 #include <kernel/k_libc.h>
 200004 #include <inttypes.h>
 200005 #include <stdio.h>
 200006 //----------------------------------------------------------------------
 200007 void
 200008 print_hex_32_reverse (void *data, size_t elements)
 200009 {
 200010     uint32_t *element = (uint32_t *) data;
 200011     int i;
 200012     for (i = 0; i < elements; i++)
 200013       {
 200014         k_printf ("%08" PRIx32, reverse_32_bit (element[i]));
 200015       }
 200016 }

 210001 #include <sys/os16.h>
 210002 #include <kernel/diag.h>
 210003 #include <kernel/k_libc.h>
 210004 #include <inttypes.h>
 210005 #include <stdio.h>
 210006 //----------------------------------------------------------------------
 210007 void
 210008 print_hex_8 (void *data, size_t elements)
 210009 {
 210010     uint8_t *element = (uint8_t *) data;
 210011     int i;
 210012     for (i = 0; i < elements; i++)
 210013       {
 210014         k_printf ("%02" PRIx8, (uint16_t) element[i]);
 210015       }
 210016 }

 220001 #include <sys/os16.h>
 220002 #include <kernel/diag.h>
 220003 #include <kernel/k_libc.h>
 220004 #include <inttypes.h>
 220005 #include <stdio.h>
 220006 //----------------------------------------------------------------------
 220007 void
 220008 print_hex_8_reverse (void *data, size_t elements)
 220009 {
 220010     uint8_t *element = (uint8_t *) data;
 220011     int i;
 220012     for (i = 0; i < elements; i++)
 220013       {
 220014         k_printf ("%02" PRIx8, reverse_8_bit (element[i]));
 220015       }
 220016 }

 230001 #include <sys/os16.h>
 230002 #include <kernel/diag.h>
 230003 #include <kernel/k_libc.h>
 230004 //----------------------------------------------------------------------
 230005 void
 230006 print_inode (inode_t *inode)
 230007 {
 230008     unsigned long int seconds;
 230009     unsigned long int seconds_d;
 230010     unsigned long int seconds_h;
 230011     unsigned int      d;
 230012     unsigned int      h;
 230013     unsigned int      m;
 230014     unsigned int      s;
 230015     dev_t             device_attached = 0;
 230016     //
 230017     if (inode == NULL)
 230018       {
 230019         return;
 230020       }
 230021     //
 230022     seconds    = inode->time;
 230023     d          = seconds / 86400L;              // 24 * 60 * 60
 230024     seconds_d  = d;
 230025     seconds_d *= 86400;
 230026     seconds   -= seconds_d;
 230027     h          = seconds / 3840;                // 60 * 60
 230028     seconds_h  = h;
 230029     seconds_h *= 3840;
 230030     seconds   -= seconds_h;    
 230031     m          = seconds / 60;
 230032     s          = seconds % 60;
 230033     //
 230034     if (inode->sb_attached != NULL)
 230035       {
 230036         device_attached = inode->sb_attached->device;
 230037       }
 230038     //
 230039     k_printf ("%04x %4i %3i %c %4x %06o %4i %3i %7li ",
 230040               (unsigned int) inode->sb->device,
 230041               (unsigned int) inode->ino,
 230042               (unsigned int) inode->references,
 230043               (inode->changed ? '!' : ' '),
 230044               (unsigned int) device_attached,
 230045               (unsigned int) inode->mode,
 230046               (unsigned int) inode->uid,
 230047               (unsigned int) inode->gid,
 230048               (unsigned long int) inode->size);
 230049 
 230050     k_printf ("%5i %2i:%02i:%02i %3i\n",
 230051               d, h, m, s,
 230052               (unsigned int) inode->links);
 230053 
 230054 }

 240001 #include <sys/os16.h>
 240002 #include <kernel/diag.h>
 240003 #include <kernel/k_libc.h>
 240004 //----------------------------------------------------------------------
 240005 void
 240006 print_inode_head (void)
 240007 {
 240008     k_printf (" dev  ino ref c mntd   mode  uid gid    ");
 240009     k_printf ("size  date     time lnk \n");
 240010 }

 250001 #include <sys/os16.h>
 250002 #include <kernel/diag.h>
 250003 #include <kernel/k_libc.h>
 250004 //----------------------------------------------------------------------
 250005 void
 250006 print_inode_list (void)
 250007 {
 250008     ino_t ino;
 250009     inode_t *inode = inode_reference (0, 0);
 250010     print_inode_head ();
 250011     for (ino = 0; ino < INODE_MAX_SLOTS; ino++)
 250012       {
 250013         if (inode[ino].references > 0)
 250014           {
 250015             print_inode (&inode[ino]);
 250016           }
 250017       }
 250018 }

 260001 #include <sys/os16.h>
 260002 #include <kernel/diag.h>
 260003 #include <kernel/k_libc.h>
 260004 //----------------------------------------------------------------------
 260005 void
 260006 print_inode_map (sb_t *sb, uint16_t *bitmap)
 260007 {
 260008     size_t size;
 260009     if (sb->inodes % 16)
 260010       {
 260011         size = sb->inodes/16 + 1;
 260012       }
 260013     else
 260014       {
 260015         size = sb->inodes/16;
 260016       }
 260017     print_hex_16_reverse (bitmap, size);
 260018 }

 270001 #include <sys/os16.h>
 270002 #include <kernel/diag.h>
 270003 #include <kernel/k_libc.h>
 270004 //----------------------------------------------------------------------
 270005 void
 270006 print_inode_zones_list (void)
 270007 {
 270008     ino_t ino;
 270009     inode_t *inode = inode_reference (0, 0);
 270010     print_inode_zones_head ();
 270011     for (ino = 0; ino < INODE_MAX_SLOTS; ino++)
 270012       {
 270013         if (inode[ino].references > 0)
 270014           {
 270015             print_inode_zones (&inode[ino]);
 270016           }
 270017       }
 270018 }

 280001 #include <sys/os16.h>
 280002 #include <kernel/diag.h>
 280003 #include <kernel/k_libc.h>
 280004 //----------------------------------------------------------------------
 280005 void
 280006 print_inode_zones (inode_t *inode)
 280007 {
 280008     int i;
 280009     //
 280010     if (inode == NULL)
 280011       {
 280012         return;
 280013       }
 280014     //
 280015     k_printf ("%04x %4i ",
 280016               (unsigned int) inode->sb->device,
 280017               (unsigned int) inode->ino);
 280018 
 280019     for (i = 0; i < 7; i++)
 280020       {
 280021         if (inode->direct[i] != 0)
 280022           {
 280023             k_printf ("%04x ", (unsigned int) inode->direct[i]);
 280024           }
 280025         else
 280026           {
 280027             k_printf ("     ");
 280028           }
 280029       }
 280030     if (inode->indirect1 != 0)
 280031       {
 280032         k_printf ("%04x ",     (unsigned int) inode->indirect1);
 280033       }
 280034     else
 280035       {
 280036         k_printf ("     ");
 280037       }
 280038     if (inode->indirect2 != 0)
 280039       {
 280040         k_printf ("%04x",      (unsigned int) inode->indirect2);
 280041       }
 280042     else
 280043       {
 280044         k_printf ("    ");
 280045       }
 280046     k_printf ("\n");
 280047 }

 290001 #include <sys/os16.h>
 290002 #include <kernel/diag.h>
 290003 #include <kernel/k_libc.h>
 290004 //----------------------------------------------------------------------
 290005 void
 290006 print_inode_zones_head (void)
 290007 {
 290008     k_printf (" dev  ino zn_0 zn_1 zn_2 zn_3 zn_4 zn_5 zn_6 ");
 290009     k_printf ("ind1 ind2\n");
 290010 }

 300001 #include <sys/os16.h>
 300002 #include <kernel/diag.h>
 300003 #include <kernel/k_libc.h>
 300004 //----------------------------------------------------------------------
 300005 extern uint16_t _ksp;
 300006 extern uint16_t _etext;
 300007 extern uint16_t _edata;
 300008 extern uint16_t _end;
 300009 //----------------------------------------------------------------------
 300010 void
 300011 print_kmem (void)
 300012 {
 300013     k_printf ("etext=%04x edata=%04x ebss=%04x ksp=%04x",
 300014               (unsigned int) &_etext,
 300015               (unsigned int) &_edata, (unsigned int) &_end, _ksp);
 300016 }

 310001 #include <sys/os16.h>
 310002 #include <kernel/diag.h>
 310003 #include <kernel/k_libc.h>
 310004 //----------------------------------------------------------------------
 310005 void
 310006 print_mb_map (void)
 310007 {
 310008     uint16_t    *mb = mb_reference ();
 310009     unsigned int i;
 310010     for (i = 0; i < (MEM_MAX_BLOCKS / 16); i++)
 310011       {
 310012         k_printf ("%04x", mb[i]);
 310013       }
 310014 }

 320001 #include <sys/os16.h>
 320002 #include <kernel/diag.h>
 320003 #include <kernel/k_libc.h>
 320004 //----------------------------------------------------------------------
 320005 void
 320006 print_memory_map (void)
 320007 {
 320008     uint16_t    *mem_block[MEM_BLOCK_SIZE/2];
 320009     uint16_t     block_rank;
 320010     unsigned int b;
 320011     unsigned int m;
 320012     unsigned int i;
 320013     addr_t       start;
 320014 
 320015     start = 0;
 320016     dev_io ((pid_t) -1, DEV_MEM, DEV_READ, start, mem_block,
 320017             MEM_BLOCK_SIZE, NULL);
 320018 
 320019     for (m = 0; m < MEM_MAX_BLOCKS; m++)
 320020       {
 320021         i = m % 16;
 320022         if (i == 0)
 320023           {
 320024             block_rank = 0;
 320025           }
 320026         //
 320027         for (b = 0; b < (MEM_BLOCK_SIZE / 2); b++)
 320028           {
 320029             if (mem_block[b])
 320030               {
 320031                 block_rank |= (0x8000 >> i);
 320032                 break;
 320033               }
 320034           }
 320035         //
 320036         if (i == 15)
 320037           {
 320038             k_printf ("%04x", block_rank);
 320039           }
 320040         //
 320041         start += MEM_BLOCK_SIZE;
 320042         dev_io ((pid_t) -1, DEV_MEM, DEV_READ, start, mem_block,
 320043                 MEM_BLOCK_SIZE, NULL);
 320044       }
 320045 }

 330001 #include <sys/os16.h>
 330002 #include <kernel/diag.h>
 330003 #include <kernel/k_libc.h>
 330004 //----------------------------------------------------------------------
 330005 void
 330006 print_proc_head (void)
 330007 {
 330008     k_printf (
 330009 "pp  p pg                                                            \n"
 330010 "id id rp  tty  uid euid suid usage s iaddr isiz daddr dsiz sp   name\n"
 330011            );
 330012 }

 340001 #include <sys/os16.h>
 340002 #include <kernel/diag.h>
 340003 #include <kernel/k_libc.h>
 340004 //----------------------------------------------------------------------
 340005 void
 340006 print_proc_list (void)
 340007 {
 340008     pid_t   pid;
 340009     proc_t *ps;
 340010     //
 340011     print_proc_head ();
 340012     //
 340013     for (pid = 0; pid < PROCESS_MAX; pid++)
 340014       {
 340015         ps = proc_reference (pid);
 340016         if (ps != NULL && ps->status > 0)
 340017           {
 340018             print_proc_pid (ps, pid);
 340019           }
 340020       }
 340021 }

 350001 #include <sys/os16.h>
 350002 #include <kernel/diag.h>
 350003 #include <kernel/k_libc.h>
 350004 //----------------------------------------------------------------------
 350005 void
 350006 print_proc_pid (proc_t *ps, pid_t pid)
 350007 {
 350008     char  stat;
 350009     switch (ps->status)
 350010       {
 350011         case PROC_EMPTY   : stat = '-'; break;
 350012         case PROC_CREATED : stat = 'c'; break;
 350013         case PROC_READY   : stat = 'r'; break;
 350014         case PROC_RUNNING : stat = 'R'; break;
 350015         case PROC_SLEEPING: stat = 's'; break;
 350016         case PROC_ZOMBIE  : stat = 'z'; break;
 350017         default           : stat = '?'; break;
 350018       }
 350019 
 350020     k_printf ("%2i %2i %2i %04x %4i %4i %4i %02i.%02i %c %05lx %04x ",
 350021               (unsigned int) ps->ppid,
 350022               (unsigned int) pid,
 350023               (unsigned int) ps->pgrp,
 350024               (unsigned int) ps->device_tty,
 350025               (unsigned int) ps->uid,
 350026               (unsigned int) ps->euid,
 350027               (unsigned int) ps->suid,
 350028               (unsigned int) ((ps->usage / CLOCKS_PER_SEC) / 60),
 350029               (unsigned int) ((ps->usage / CLOCKS_PER_SEC) % 60),
 350030               stat,
 350031               (unsigned long int) ps->address_i,
 350032               (unsigned int) ps->size_i);
 350033 
 350034     k_printf ("%05lx %04x %04x %s",
 350035               (unsigned long int) ps->address_d,
 350036               (unsigned int) ps->size_d,
 350037               (unsigned int) ps->sp,
 350038                              ps->name);
 350039 
 350040     k_printf ("\n");
 350041 }

 360001 #include <sys/os16.h>
 360002 #include <kernel/diag.h>
 360003 #include <kernel/k_libc.h>
 360004 //----------------------------------------------------------------------
 360005 void
 360006 print_segments (void)
 360007 {
 360008     k_printf ("CS=%04x DS=%04x SS=%04x ES=%04x BP=%04x SP=%04x ",
 360009               cs (), ds (), ss (), es (), bp (), sp ());
 360010     k_printf ("heap_min=%04x", heap_min ());
 360011 }

 370001 #include <sys/os16.h>
 370002 #include <kernel/diag.h>
 370003 #include <kernel/k_libc.h>
 370004 //----------------------------------------------------------------------
 370005 void
 370006 print_superblock (sb_t *sb)
 370007 {
 370008     k_printf ("Inodes:           %i\n", sb->inodes);
 370009     k_printf ("Blocks:           %i\n", sb->zones);
 370010     k_printf ("First data zone:  %i\n", sb->first_data_zone);
 370011     k_printf ("Zone size:        %i\n", (1024 << sb->log2_size_zone));
 370012     k_printf ("Max file size:    %li\n", sb->max_file_size);
 370013     k_printf ("Inode map blocks: %i\n", sb->map_inode_blocks);
 370014     k_printf ("Zone map blocks:  %i\n", sb->map_zone_blocks);
 370015 }

 380001 #include <sys/os16.h>
 380002 #include <kernel/diag.h>
 380003 #include <kernel/k_libc.h>
 380004 //----------------------------------------------------------------------
 380005 void
 380006 print_time (void)
 380007 {
 380008     unsigned long int ticks   = k_clock ();
 380009     unsigned long int seconds = k_time (NULL);
 380010     unsigned int      h       = seconds / 60 / 60;
 380011     unsigned int      m       = seconds / 60 - h * 60;
 380012     unsigned int      s       = seconds - m * 60 - h * 60 * 60;
 380013     k_printf ("clock=%08lx, time elapsed=%02u:%02u:%02u",
 380014               ticks, h, m, s);
 380015 }

 390001 #include <sys/os16.h>
 390002 #include <kernel/diag.h>
 390003 #include <kernel/k_libc.h>
 390004 //----------------------------------------------------------------------
 390005 void
 390006 print_zone_map (sb_t *sb, uint16_t *bitmap)
 390007 {
 390008     size_t       size;
 390009     unsigned int data_zones = sb->zones - sb->first_data_zone;
 390010     if (data_zones % 16)
 390011       {
 390012         size = data_zones/16 + 1;
 390013       }
 390014     else
 390015       {
 390016         size = data_zones/16;
 390017       }
 390018     print_hex_16_reverse (bitmap, size);
 390019 }

 400001 #include <sys/os16.h>
 400002 #include <kernel/diag.h>
 400003 #include <kernel/k_libc.h>
 400004 #include <inttypes.h>
 400005 //----------------------------------------------------------------------
 400006 uint16_t
 400007 reverse_16_bit (uint16_t source)
 400008 {
 400009     uint16_t destination = 0;
 400010     uint16_t mask_src;
 400011     uint16_t mask_dst;
 400012     int      i;
 400013     for (i = 0; i < 16; i++)
 400014       {
 400015         mask_src = 0x0001 << i;
 400016         mask_dst = 0x8000 >> i;
 400017         if (source & mask_src)
 400018           {
 400019             destination |= mask_dst;
 400020           }
 400021       }
 400022     return (destination);
 400023 }

 410001 #include <sys/os16.h>
 410002 #include <kernel/diag.h>
 410003 #include <kernel/k_libc.h>
 410004 //----------------------------------------------------------------------
 410005 uint32_t
 410006 reverse_32_bit (uint32_t source)
 410007 {
 410008     uint32_t destination = 0;
 410009     uint32_t mask_src;
 410010     uint32_t mask_dst;
 410011     int      i;
 410012     for (i = 0; i < 32; i++)
 410013       {
 410014         mask_src = 0x00000001 << i;
 410015         mask_dst = 0x80000000 >> i;
 410016         if (source & mask_src)
 410017           {
 410018             destination |= mask_dst;
 410019           }
 410020       }
 410021     return (destination);
 410022 }

 420001 #include <sys/os16.h>
 420002 #include <kernel/diag.h>
 420003 #include <kernel/k_libc.h>
 420004 #include <inttypes.h>
 420005 //----------------------------------------------------------------------
 420006 uint8_t
 420007 reverse_8_bit (uint8_t source)
 420008 {
 420009     uint8_t destination = 0;
 420010     uint8_t mask_src;
 420011     uint8_t mask_dst;
 420012     int      i;
 420013     for (i = 0; i < 8; i++)
 420014       {
 420015         mask_src = 0x01 << i;
 420016         mask_dst = 0x80 >> i;
 420017         if (source & mask_src)
 420018           {
 420019             destination |= mask_dst;
 420020           }
 420021       }
 420022     return (destination);
 420023 }

 430001 #ifndef _KERNEL_FS_H
 430002 #define _KERNEL_FS_H 1
 430003 
 430004 #include <stdint.h>
 430005 #include <sys/types.h>
 430006 #include <kernel/memory.h>
 430007 #include <sys/os16.h>
 430008 #include <sys/stat.h>
 430009 #include <stdint.h>
 430010 #include <const.h>
 430011 #include <stdio.h>
 430012 #include <limits.h>
 430013 
 430014 //----------------------------------------------------------------------
 430015 #define SB_MAX_INODE_BLOCKS          1  // 8192 inodes max.
 430016 #define SB_MAX_ZONE_BLOCKS           1  // 8192 data-zones max.
 430017 #define SB_BLOCK_SIZE             1024  // Fixed for Minix file system.
 430018 #define SB_MAX_ZONE_SIZE          2048  // log2 max is 1.
 430019 #define SB_MAP_INODE_SIZE         (SB_MAX_INODE_BLOCKS*512) // [1]
 430020 #define SB_MAP_ZONE_SIZE          (SB_MAX_ZONE_BLOCKS*512)  // [1]
 430021 //
 430022 // [1] blocks * (1024 * 8 / 16) = number of bits, divided 16.
 430023 //
 430024 //----------------------------------------------------------------------
 430025 #define INODE_MAX_INDIRECT_ZONES  (SB_MAX_ZONE_SIZE/2)      // [2]
 430026 
 430027 #define INODE_MAX_REFERENCES      0xFF
 430028 //
 430029 // [2] number of zone pointers contained inside a zone, used
 430030 //     as an indirect inode list (a pointer = 16 bits = 2 bytes).
 430031 //
 430032 //----------------------------------------------------------------------
 430033 typedef uint16_t        zno_t;          // Zone number.
 430034 //----------------------------------------------------------------------
 430035 // The structured type `inode_t' must be pre-declared here, because
 430036 // the type sb_t, described before the inode structure, has a member
 430037 // pointing to a type `inode_t'. So, must be declared previously
 430038 // the type `inode_t' as made of a type `struct inode', then the
 430039 // structure `inode' can be described. But for a matter of coherence,
 430040 // all other structured data declared inside this file follow the
 430041 // same procedure.
 430042 //
 430043 typedef struct sb        sb_t;
 430044 typedef struct inode     inode_t;
 430045 typedef struct file      file_t;
 430046 typedef struct fd        fd_t;
 430047 typedef struct directory directory_t;
 430048 //----------------------------------------------------------------------
 430049 #define SB_MAX_SLOTS  2                 // Handle max 2 file systems.
 430050 
 430051 struct sb {                             // File system super block:
 430052     uint16_t      inodes;               // inodes available;
 430053     uint16_t      zones;                // zones available (disk size);
 430054     uint16_t      map_inode_blocks;     // inode bit map blocks;
 430055     uint16_t      map_zone_blocks;      // data-zone bit map blocks;
 430056     uint16_t      first_data_zone;      // first data-zone;
 430057     uint16_t      log2_size_zone;       // log_2 (size_zone/block_size);
 430058     uint32_t      max_file_size;        // max file size in bytes;
 430059     uint16_t      magic_number;         // file system magic number.
 430060     //------------------------------------------------------------------
 430061     // Extra management data, not saved inside the file system
 430062     // super block.
 430063     //------------------------------------------------------------------
 430064     dev_t         device;                       // FS device [3]
 430065     inode_t      *inode_mounted_on;             // [4]
 430066     blksize_t     blksize;                      // Calculated zone size.
 430067     int           options;                      // [5]
 430068     uint16_t      map_inode[SB_MAP_INODE_SIZE];
 430069     uint16_t      map_zone[SB_MAP_ZONE_SIZE];
 430070     char          changed;
 430071 };
 430072 
 430073 extern sb_t    sb_table[SB_MAX_SLOTS];
 430074 //
 430075 // [3] the member `device' must be kept at the same position, because
 430076 //     it is used to calculate the super block header size, saved on
 430077 //     disk.
 430078 //
 430079 // [4] If this pointer is not NULL, the super block is related to a
 430080 //     device mounted on a directory. The inode of such directory is
 430081 //     recorded here. Please note that it is type `void *', instead of
 430082 //     type `inode_t', because type `inode_t' is declared after type
 430083 //     `sb_t'.
 430084 //     Please note that the type `sb_t' is declared before the
 430085 //     type `inode_t', but this member points to a type `inode_t'.
 430086 //     This is the reason because it was necessary to declare first
 430087 //     the type `inode_t' as made of `struct inode', to be described
 430088 //     later. For coherence, all derived type made of structured data,
 430089 //     are first declared as structure, and then, later, described.
 430090 //
 430091 // [5] Mount options can be only `MOUNT_DEFAULT' or `MOUNT_RO',
 430092 //     as defined inside file `lib/sys/os16.h'.
 430093 //
 430094 //----------------------------------------------------------------------
 430095 #define INODE_MAX_SLOTS           (8 * OPEN_MAX)
 430096 
 430097 struct inode {                          // Inode (32 byte total):
 430098     mode_t        mode;                 // file type and permissions;
 430099     uid_t         uid;                  // user ID (16 bit);
 430100     ssize_t       size;                 // file size in bytes;
 430101     time_t        time;                 // file data modification time;
 430102     uint8_t       gid;                  // group ID (8 bit);
 430103     uint8_t       links;                // links to the inode;
 430104     zno_t         direct[7];            // direct zones;
 430105     zno_t         indirect1;            // indirect zones;
 430106     zno_t         indirect2;            // double indirect zones.
 430107     //------------------------------------------------------------------
 430108     // Extra management data, not saved inside the disk file system.
 430109     //------------------------------------------------------------------
 430110     sb_t         *sb;                   // Inode's super block. [7]
 430111     ino_t         ino;                  // Inode number.
 430112     sb_t         *sb_attached;          // [8]
 430113     blkcnt_t      blkcnt;               // Rounded size/blksize.
 430114     unsigned char references;           // Run time active references.
 430115     char          changed;              // 1 == to be saved.
 430116 };
 430117 
 430118 extern inode_t inode_table[INODE_MAX_SLOTS];
 430119 //
 430120 // [7] the member `sb' must be kept at the same position, because
 430121 //     it is used to calculate the inode header size, saved on disk.
 430122 //
 430123 // [8] If the inode is a mount point for another device, the other
 430124 //     super block pointer is saved inside `sb_attached'.
 430125 //
 430126 //----------------------------------------------------------------------
 430127 #define FILE_MAX_SLOTS             (16 * OPEN_MAX)
 430128 
 430129 struct file {
 430130     int           references;
 430131     off_t         offset;               // File position.
 430132     int           oflags;               // Open mode: r/w/r+w [9]
 430133     inode_t      *inode;
 430134 };
 430135 
 430136 extern file_t file_table[FILE_MAX_SLOTS];
 430137 //
 430138 // [9] the member `oflags' can get only O_RDONLY, O_WRONLY, O_RDWR,
 430139 //     (from header `fcntl.h') combined with OR binary operator.
 430140 //
 430141 //----------------------------------------------------------------------
 430142 struct fd {
 430143     int           fl_flags;             // File status flags and file
 430144                                         // access modes. [10]
 430145     int           fd_flags;             // File descriptor flags:
 430146                                         // currently only FD_CLOEXEC.
 430147     file_t       *file;                 // Pointer to the file table.
 430148 };
 430149 //
 430150 // [10] the member `fl_flags' can get only O_RDONLY, O_WRONLY, O_RDWR,
 430151 //      O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC and O_APPEND
 430152 //      (from header `fcntl.h') combined with OR binary
 430153 //      operator. Options like O_DSYNC, O_NONBLOCK, O_RSYNC and O_SYNC
 430154 //      are not taken into consideration by os16.
 430155 //
 430156 //----------------------------------------------------------------------
 430157 struct directory {                      // Directory entry:
 430158     ino_t         ino;                  // inode number;
 430159     char          name[NAME_MAX];       // file name.
 430160 };
 430161 //----------------------------------------------------------------------
 430162 sb_t    *sb_reference    (dev_t device);
 430163 sb_t    *sb_mount        (dev_t device, inode_t **inode_mnt,
 430164                           int options);
 430165 sb_t    *sb_get          (dev_t device, sb_t *sb);
 430166 int      sb_save         (sb_t *sb);
 430167 int      sb_zone_status  (sb_t *sb, zno_t zone);
 430168 int      sb_inode_status (sb_t *sb, ino_t ino);
 430169 //----------------------------------------------------------------------
 430170 zno_t    zone_alloc           (sb_t *sb);
 430171 int      zone_free            (sb_t *sb, zno_t zone);
 430172 int      zone_read            (sb_t *sb, zno_t zone, void *buffer);
 430173 int      zone_write           (sb_t *sb, zno_t zone, void *buffer);
 430174 //----------------------------------------------------------------------
 430175 inode_t *inode_reference      (dev_t device, ino_t ino);
 430176 inode_t *inode_alloc          (dev_t device, mode_t mode, uid_t uid);
 430177 int      inode_free           (inode_t *inode);
 430178 inode_t *inode_get            (dev_t device, ino_t ino);
 430179 int      inode_save           (inode_t *inode);
 430180 int      inode_put            (inode_t *inode);
 430181 int      inode_truncate       (inode_t *inode);
 430182 zno_t    inode_zone           (inode_t *inode, zno_t fzone, int write);
 430183 inode_t *inode_stdio_dev_make (dev_t device, mode_t mode);
 430184 blkcnt_t inode_fzones_read    (inode_t *inode, zno_t zone_start,
 430185                                void *buffer, blkcnt_t blkcnt);
 430186 blkcnt_t inode_fzones_write   (inode_t *inode, zno_t zone_start,
 430187                                void *buffer, blkcnt_t blkcnt);
 430188 ssize_t  inode_file_read      (inode_t *inode, off_t offset,
 430189                                void *buffer, size_t count, int *eof);
 430190 ssize_t  inode_file_write     (inode_t *inode, off_t offset,
 430191                                void *buffer, size_t count);
 430192 int      inode_check          (inode_t *inode, mode_t type,
 430193                                int perm, uid_t uid);
 430194 int      inode_dir_empty      (inode_t *inode);
 430195 //----------------------------------------------------------------------
 430196 file_t  *file_reference       (int fno);
 430197 file_t  *file_stdio_dev_make  (dev_t device, mode_t mode, int oflags);
 430198 //----------------------------------------------------------------------
 430199 inode_t *path_inode      (pid_t pid, const char *path);
 430200 int      path_chdir      (pid_t pid, const char *path);
 430201 dev_t    path_device     (pid_t pid, const char *path);
 430202 int      path_full       (const char *path,
 430203                           const char *path_cwd,
 430204                           char *full_path);
 430205 int      path_fix        (char *path);
 430206 inode_t *path_inode_link (pid_t pid, const char *path, inode_t *inode,
 430207                           mode_t mode);
 430208 int      path_link       (pid_t pid, const char *path_old,
 430209                           const char *path_new);
 430210 int      path_mkdir      (pid_t pid, const char *path, mode_t mode);
 430211 int      path_mknod      (pid_t pid, const char *path, mode_t mode,
 430212                           dev_t device);
 430213 int      path_mount      (pid_t pid, const char *path_dev,
 430214                           const char *path_mnt,
 430215                           int options);
 430216 int      path_umount     (pid_t pid, const char *path_mnt);
 430217 int      path_stat       (pid_t pid, const char *path,
 430218                           struct stat *buffer);
 430219 int      path_chmod      (pid_t pid, const char *path, mode_t mode);
 430220 int      path_chown      (pid_t pid, const char *path, uid_t uid,
 430221                           gid_t gid);
 430222 int      path_unlink     (pid_t pid, const char *path);
 430223 //----------------------------------------------------------------------
 430224 fd_t    *fd_reference (pid_t pid, int *fdn);
 430225 int      fd_chmod     (pid_t pid, int fdn, mode_t mode);
 430226 int      fd_chown     (pid_t pid, int fdn, uid_t uid, gid_t gid);
 430227 int      fd_close     (pid_t pid, int fdn);
 430228 int      fd_fcntl     (pid_t pid, int fdn, int cmd, int arg);
 430229 int      fd_dup       (pid_t pid, int fdn_old, int fdn_min);
 430230 int      fd_dup2      (pid_t pid, int fdn_old, int fdn_new);
 430231 off_t    fd_lseek     (pid_t pid, int fdn, off_t offset, int whence);
 430232 int      fd_open      (pid_t pid, const char *path, int oflags,
 430233                        mode_t mode);
 430234 ssize_t  fd_read      (pid_t pid, int fdn, void *buffer, size_t count,
 430235                        int *eof);
 430236 int      fd_stat      (pid_t pid, int fdn, struct stat *buffer);
 430237 ssize_t  fd_write     (pid_t pid, int fdn, const void *buffer,
 430238                        size_t count);
 430239 //----------------------------------------------------------------------
 430240 
 430241 #endif

 440001 #include <kernel/proc.h>
 440002 #include <kernel/k_libc.h>
 440003 #include <sys/stat.h>
 440004 #include <errno.h>
 440005 //----------------------------------------------------------------------
 440006 int
 440007 fd_chmod (pid_t pid, int fdn, mode_t mode)
 440008 {
 440009     proc_t   *ps;
 440010     inode_t  *inode;
 440011     //
 440012     // Get process.
 440013     //
 440014     ps = proc_reference (pid);
 440015     //
 440016     // Verify if the file descriptor is valid.
 440017     //
 440018     if (ps->fd[fdn].file == NULL)
 440019       {
 440020         errset (EBADF);         // Bad file descriptor.
 440021         return (-1);
 440022       }
 440023     //
 440024     // Reach the inode.
 440025     //
 440026     inode = ps->fd[fdn].file->inode;
 440027     //
 440028     // Verify to be the owner, or at least to be UID == 0.
 440029     //
 440030     if (ps->euid != inode->uid && ps->euid != 0)
 440031       {
 440032         errset (EACCES);        // Permission denied.
 440033         return (-1);
 440034       }
 440035     //
 440036     // Update the mode: the file type is kept and the
 440037     // rest is taken form the parameter `mode'.
 440038     //
 440039     inode->mode = (S_IFMT & inode->mode) | (~S_IFMT & mode);
 440040     //
 440041     // Save the inode.
 440042     //
 440043     inode->changed = 1;
 440044     inode_save (inode);
 440045     //
 440046     // Return.
 440047     //
 440048     return (0);
 440049 }

 450001 #include <kernel/proc.h>
 450002 #include <kernel/k_libc.h>
 450003 #include <errno.h>
 450004 //----------------------------------------------------------------------
 450005 int
 450006 fd_chown (pid_t pid, int fdn, uid_t uid, gid_t gid)
 450007 {
 450008     proc_t   *ps;
 450009     inode_t  *inode;
 450010     //
 450011     // Get process.
 450012     //
 450013     ps = proc_reference (pid);
 450014     //
 450015     // Verify if the file descriptor is valid.
 450016     //
 450017     if (ps->fd[fdn].file == NULL)
 450018       {
 450019         errset (EBADF);         // Bad file descriptor.
 450020         return (-1);
 450021       }
 450022     //
 450023     // Reach the inode.
 450024     //
 450025     inode = ps->fd[fdn].file->inode;
 450026     //
 450027     // Verify to be root, as the ability to change group
 450028     // is not taken into consideration.
 450029     //
 450030     if (ps->euid != 0)
 450031       {
 450032         errset (EACCES);        // Permission denied.
 450033         return (-1);
 450034       }
 450035     //
 450036     // Update the ownership.
 450037     //
 450038     if (uid != -1)
 450039       {
 450040         inode->uid     = uid;
 450041         inode->changed = 1;
 450042       }
 450043     if (gid != -1)
 450044       {
 450045         inode->gid     = gid;
 450046         inode->changed = 1;
 450047       }
 450048     //
 450049     // Save the inode.
 450050     //
 450051     inode->changed = 1;
 450052     inode_save (inode);
 450053     //
 450054     // Return.
 450055     //
 450056     return (0);
 450057 }

 460001 #include <kernel/proc.h>
 460002 #include <kernel/k_libc.h>
 460003 #include <errno.h>
 460004 //----------------------------------------------------------------------
 460005 int
 460006 fd_close (pid_t pid, int fdn)
 460007 {
 460008     inode_t           *inode;
 460009     file_t            *file;
 460010     fd_t *fd;
 460011     //
 460012     // Get file descriptor.
 460013     //
 460014     fd = fd_reference (pid, &fdn);
 460015     if (fd == NULL                ||
 460016         fd->file == NULL          ||
 460017         fd->file->inode == NULL )
 460018       {
 460019         errset (EBADF);         // Bad file descriptor.
 460020         return (-1);
 460021       }
 460022     //
 460023     // Get file.
 460024     //
 460025     file = fd->file;
 460026     //
 460027     // Get inode.
 460028     //
 460029     inode = file->inode;
 460030     //
 460031     // Reduce references inside the file table item
 460032     // and remove item if it reaches zero.
 460033     //
 460034     file->references--;
 460035     if (file->references == 0)
 460036       {
 460037         file->oflags = 0;
 460038         file->inode  = NULL;
 460039         //
 460040         // Put inode, because there are no more file references.
 460041         //
 460042         inode_put (inode);
 460043       }
 460044     //
 460045     // Remove file descriptor.
 460046     //
 460047     fd->fl_flags = 0;
 460048     fd->fd_flags = 0;
 460049     fd->file  = NULL;
 460050     //
 460051     //
 460052     //
 460053     return (0);
 460054 }

 470001 #include <kernel/proc.h>
 470002 #include <kernel/k_libc.h>
 470003 #include <errno.h>
 470004 #include <fcntl.h>
 470005 //----------------------------------------------------------------------
 470006 int
 470007 fd_dup (pid_t pid, int fdn_old, int fdn_min)
 470008 {
 470009     proc_t *ps;
 470010     int     fdn_new;
 470011     //
 470012     // Verify argument.
 470013     //
 470014     if (fdn_min < 0 || fdn_min >= OPEN_MAX)
 470015       {
 470016         errset (EINVAL);                 // Invalid argument.
 470017         return (-1);
 470018       }
 470019     //
 470020     // Get process.
 470021     //
 470022     ps = proc_reference (pid);
 470023     //
 470024     // Verify if `fdn_old' is a valid value.
 470025     //
 470026     if (fdn_old < 0                     ||
 470027         fdn_old >= OPEN_MAX             ||
 470028         ps->fd[fdn_old].file == NULL)
 470029       {
 470030         errset (EBADF);                 // Bad file descriptor.
 470031         return (-1);
 470032       }
 470033     //
 470034     // Find the first free slot and duplicate the file descriptor.
 470035     //
 470036     for (fdn_new = fdn_min; fdn_new < OPEN_MAX; fdn_new++)
 470037       {
 470038         if (ps->fd[fdn_new].file == NULL)
 470039           {
 470040             ps->fd[fdn_new].fl_flags = ps->fd[fdn_old].fl_flags;
 470041             ps->fd[fdn_new].fd_flags
 470042                 = ps->fd[fdn_old].fd_flags & ~FD_CLOEXEC;
 470043             ps->fd[fdn_new].file = ps->fd[fdn_old].file;
 470044             ps->fd[fdn_new].file->references++;
 470045             return (fdn_new);
 470046           }
 470047       }
 470048     //
 470049     // No fd slot available.
 470050     //
 470051     errset (EMFILE);            // Too many open files.
 470052     return (-1);
 470053 }

 480001 #include <kernel/proc.h>
 480002 #include <kernel/k_libc.h>
 480003 #include <errno.h>
 480004 #include <fcntl.h>
 480005 //----------------------------------------------------------------------
 480006 int
 480007 fd_dup2 (pid_t pid, int fdn_old, int fdn_new)
 480008 {
 480009     proc_t *ps;
 480010     int     status;
 480011     //
 480012     // Get process.
 480013     //
 480014     ps = proc_reference (pid);
 480015     //
 480016     // Verify if `fdn_old' is a valid value.
 480017     //
 480018     if (fdn_old < 0                     ||
 480019         fdn_old >= OPEN_MAX             ||
 480020         ps->fd[fdn_old].file == NULL)
 480021       {
 480022         errset (EBADF);                 // Bad file descriptor.
 480023         return (-1);
 480024       }
 480025     //
 480026     // Check if `fd_old' and `fd_new' are the same.
 480027     //
 480028     if (fdn_old == fdn_new)
 480029       {
 480030         return (fdn_new);
 480031       }
 480032     //
 480033     // Close `fdn_new' if it is open and copy `fdn_old' into it.
 480034     //
 480035     if (ps->fd[fdn_new].file != NULL)
 480036       {
 480037         status = fd_close (pid, fdn_new);
 480038         if (status != 0)
 480039           {
 480040             return (-1);
 480041           }
 480042       }
 480043     ps->fd[fdn_new].fl_flags = ps->fd[fdn_old].fl_flags;
 480044     ps->fd[fdn_new].fd_flags = ps->fd[fdn_old].fd_flags & ~FD_CLOEXEC;
 480045     ps->fd[fdn_new].file = ps->fd[fdn_old].file;
 480046     ps->fd[fdn_new].file->references++;
 480047     return (fdn_new);
 480048 }

 490001 #include <kernel/proc.h>
 490002 #include <kernel/k_libc.h>
 490003 #include <errno.h>
 490004 #include <fcntl.h>
 490005 //----------------------------------------------------------------------
 490006 int
 490007 fd_fcntl (pid_t pid, int fdn, int cmd, int arg)
 490008 {
 490009     proc_t   *ps;
 490010     inode_t  *inode;
 490011     int       mask;
 490012     //
 490013     // Get process.
 490014     //
 490015     ps = proc_reference (pid);
 490016     //
 490017     // Verify if the file descriptor is valid.
 490018     //
 490019     if (ps->fd[fdn].file == NULL)
 490020       {
 490021         errset (EBADF);                 // Bad file descriptor.
 490022         return (-1);
 490023       }
 490024     //
 490025     // Reach the inode.
 490026     //
 490027     inode = ps->fd[fdn].file->inode;
 490028     //
 490029     //
 490030     //
 490031     switch (cmd)
 490032       {
 490033         case F_DUPFD:
 490034             return (fd_dup (pid, fdn, arg));
 490035             break;
 490036         case F_GETFD:
 490037             return (ps->fd[fdn].fd_flags);
 490038             break;
 490039         case F_SETFD:
 490040             ps->fd[fdn].fd_flags = arg;
 490041             return (0);
 490042         case F_GETFL:
 490043             return (ps->fd[fdn].fl_flags);
 490044         case F_SETFL:
 490045             //
 490046             // Calculate a mask with bits that are not to be set.
 490047             //
 490048             mask = (O_ACCMODE
 490049                   | O_CREAT
 490050                   | O_EXCL
 490051                   | O_NOCTTY
 490052                   | O_TRUNC);
 490053             //
 490054             // Set to zero the bits that are not to be set from
 490055             // the argument.
 490056             //
 490057             arg = (arg & ~mask);
 490058             //
 490059             // Set to zero the bit that *are* to be set.
 490060             //
 490061             ps->fd[fdn].fl_flags &= mask;
 490062             //
 490063             // Set the bits, already filtered inside the argument.
 490064             //
 490065             ps->fd[fdn].fl_flags |= arg;
 490066             //
 490067             return (0);
 490068         default:
 490069             errset (EINVAL);                    // Not implemented.
 490070             return (-1);
 490071       }
 490072 }

 500001 #include <kernel/proc.h>
 500002 #include <kernel/k_libc.h>
 500003 #include <errno.h>
 500004 //----------------------------------------------------------------------
 500005 off_t
 500006 fd_lseek (pid_t pid, int fdn, off_t offset, int whence)
 500007 {
 500008     inode_t           *inode;
 500009     file_t            *file;
 500010     fd_t *fd;
 500011     off_t              test_offset;
 500012     //
 500013     // Get file descriptor.
 500014     //
 500015     fd = fd_reference (pid, &fdn);
 500016     if (fd == NULL                ||
 500017         fd->file == NULL          ||
 500018         fd->file->inode == NULL )
 500019       {
 500020         errset (EBADF);                 // Bad file descriptor.
 500021         return (-1);
 500022       }
 500023     //
 500024     // Get file table item.
 500025     //
 500026     file = fd->file;
 500027     //
 500028     // Get inode.
 500029     //
 500030     inode = file->inode;
 500031     //
 500032     // Change position depending on the `whence' parameter.
 500033     //
 500034     if (whence == SEEK_SET)
 500035       {
 500036         if (offset < 0)
 500037           {
 500038             errset (EINVAL);                    // Invalid argument.
 500039             return ((off_t) -1);
 500040           }
 500041         else
 500042           {
 500043             fd->file->offset = offset;
 500044           }
 500045       }
 500046     else if (whence == SEEK_CUR)
 500047       {
 500048         test_offset  = fd->file->offset;
 500049         test_offset += offset;
 500050         if (test_offset < 0)
 500051           {
 500052             errset (EINVAL);                    // Invalid argument.
 500053             return ((off_t) -1);
 500054           }
 500055         else
 500056           {
 500057             fd->file->offset = test_offset;
 500058           }
 500059       }
 500060     else if (whence == SEEK_END)
 500061       {
 500062         test_offset  = inode->size;
 500063         test_offset += offset;
 500064         if (test_offset < 0)
 500065           {
 500066             errset (EINVAL);                    // Invalid argument.
 500067             return ((off_t) -1);
 500068           }
 500069         else
 500070           {
 500071             fd->file->offset = test_offset;
 500072           }
 500073       }
 500074     else
 500075       {
 500076         errset (EINVAL);                        // Invalid argument.
 500077         return ((off_t) -1);
 500078       }
 500079     //
 500080     // Return the new file position.
 500081     //
 500082     return (fd->file->offset);
 500083 }

 510001 #include <kernel/proc.h>
 510002 #include <kernel/k_libc.h>
 510003 #include <errno.h>
 510004 #include <fcntl.h>
 510005 //----------------------------------------------------------------------
 510006 int
 510007 fd_open (pid_t pid, const char *path, int oflags, mode_t mode)
 510008 {
 510009     proc_t   *ps;
 510010     inode_t  *inode;
 510011     int       status;
 510012     file_t   *file;
 510013     fd_t     *fd;
 510014     int       fdn;
 510015     char      full_path[PATH_MAX];
 510016     int       perm;
 510017     tty_t    *tty;
 510018     mode_t    umask;
 510019     int       errno_save;
 510020     //
 510021     // Get process.
 510022     //
 510023     ps = proc_reference (pid);
 510024     //
 510025     // Correct the mode with the umask. As it is not a directory, to the
 510026     // mode are removed execution and sticky permissions.
 510027     //
 510028     umask = ps->umask | 01111;
 510029     mode &= ~umask;
 510030     //
 510031     // Check open options.
 510032     //
 510033     if (oflags & O_WRONLY)
 510034       {
 510035         //
 510036         // The file is to be opened for write, or for read/write.
 510037         // Try to get inode.
 510038         //
 510039         inode = path_inode (pid, path);
 510040         if (inode == NULL)
 510041           {
 510042             //
 510043             // Cannot get the inode. See if there is the creation
 510044             // option.
 510045             //
 510046             if (oflags & O_CREAT)
 510047               {
 510048                 //
 510049                 // Try to create the missing inode: the file must be a
 510050                 // regular one, so add the mode.
 510051                 //
 510052                 path_full (path, ps->path_cwd, full_path);
 510053                 inode = path_inode_link (pid, full_path, NULL,
 510054                                          (mode | S_IFREG));
 510055                 if (inode == NULL)
 510056                   {
 510057                     //
 510058                     // Sorry: cannot create the inode! Variable `errno'
 510059                     // is already set by `path_inode_link()'.
 510060                     //
 510061                     errset (errno);
 510062                     return (-1);
 510063                   }
 510064               }
 510065             else
 510066               {
 510067                 //
 510068                 // Cannot open the inode. Variable `errno'
 510069                 // should be already set by `path_inode()'.
 510070                 //
 510071                 errset (errno);
 510072                 return (-1);
 510073               }
 510074           }
 510075         //
 510076         // The inode was read or created: check if it must be
 510077         // truncated. It can be truncated only if it is a regular
 510078         // file.
 510079         //
 510080         if (oflags & O_TRUNC && inode->mode & S_IFREG)
 510081           {
 510082             //
 510083             // Truncate inode.
 510084             //
 510085             status = inode_truncate (inode);
 510086             if (status != 0)
 510087               {
 510088                 //
 510089                 // Cannot truncate the inode: release it and return.
 510090                 // But this error should never happen, because the
 510091                 // function `inode_truncate()' will not return any
 510092                 // other value than zero.
 510093                 //
 510094                 errno_save = errno;
 510095                 inode_put (inode);
 510096                 errset (errno_save);
 510097                 return (-1);
 510098               }
 510099           }
 510100       }
 510101     else
 510102       {
 510103         //
 510104         // The file is to be opened for read, but not for write.
 510105         // Try to get inode.
 510106         //
 510107         inode = path_inode (pid, path);
 510108         if (inode == NULL)
 510109           {
 510110             //
 510111             // Cannot open the file.
 510112             //
 510113             errset (errno);
 510114             return (-1);
 510115           }
 510116       }
 510117     //
 510118     // An inode was opened: check type and access permissions.
 510119     // All file types are good, even directories, as the type
 510120     // DIR is implemented through file descriptors.
 510121     //
 510122     perm = 0;
 510123     if (oflags & O_RDONLY) perm |= 4;
 510124     if (oflags & O_WRONLY) perm |= 2;
 510125     status = inode_check (inode, S_IFMT, perm, ps->uid);
 510126     if (status != 0)
 510127       {
 510128         //
 510129         // The file type is not correct or the user does not have
 510130         // permissions.
 510131         //
 510132         return (-1);
 510133       }
 510134     //
 510135     // Allocate the file, inside the file table.
 510136     //
 510137     file = file_reference (-1);
 510138     if (file == NULL)
 510139       {
 510140         //
 510141         // Cannot allocate the file inside the file table: release the
 510142         // inode, update `errno' and return.
 510143         //
 510144         inode_put (inode);
 510145         errset (ENFILE);        // Too many files open in system.
 510146         return (-1);
 510147       }
 510148     //
 510149     // Put some data inside the file item. Only options
 510150     // O_RDONLY and O_WRONLY are kept here, because the O_APPEND
 510151     // is saved inside the file descriptor table.
 510152     //
 510153     file->references = 1;
 510154     file->oflags     = (oflags & (O_RDONLY | O_WRONLY));
 510155     file->inode      = inode;
 510156     //
 510157     // Allocate the file descriptor: variable `fdn' will be modified
 510158     // by the call to `fd_reference()'.
 510159     //
 510160     fdn = -1;
 510161     fd = fd_reference (pid, &fdn);
 510162     if (fd == NULL)
 510163       {
 510164         //
 510165         // Cannot allocate the file descriptor: remove the item from
 510166         // file table.
 510167         //
 510168         file->references = 0;
 510169         file->oflags     = 0;
 510170         file->inode      = NULL;
 510171         //
 510172         // Release the inode.
 510173         //
 510174         inode_put (inode);
 510175         //
 510176         // Return an error.
 510177         //
 510178         errset (EMFILE);        // Too many open files.
 510179         return (-1);
 510180       }
 510181     //
 510182     // File descriptor allocated: put some data inside the
 510183     // file descriptor item.
 510184     //
 510185     fd->fl_flags = (oflags & (O_RDONLY | O_WRONLY | O_APPEND));
 510186     fd->fd_flags = 0;
 510187     fd->file = file;
 510188     fd->file->offset = 0;
 510189     //
 510190     // Check if it is a terminal (currently only consoles), if it is
 510191     // opened for read and write, and if it have to be set as the
 510192     // controlling terminal. This thing is done here because there is
 510193     // not a real device driver.
 510194     //
 510195     if ((S_ISCHR (inode->mode)) &&
 510196         (oflags & O_RDONLY)     &&
 510197         (oflags & O_WRONLY))
 510198       {
 510199         //
 510200         // The inode is a character special file (related to a character
 510201         // device), opened for read and write!
 510202         //
 510203         if ((inode->direct[0] & 0xFF00) == (DEV_CONSOLE_MAJOR << 8))
 510204           {
 510205             //
 510206             // It is a terminal (currently only consoles are possible).
 510207             // Get the tty reference.
 510208             //
 510209             tty = tty_reference ((dev_t) inode->direct[0]);
 510210             //
 510211             // Verify that the terminal is not already the controlling
 510212             // terminal of some process group.
 510213             //
 510214             if (tty->pgrp == 0)
 510215               {
 510216                 //
 510217                 // The terminal is free: verify if the current process
 510218                 // needs a controlling terminal.
 510219                 //
 510220                 if (ps->device_tty == 0 && ps->pgrp == pid)
 510221                   {
 510222                     //
 510223                     // It is a group leader with no controlling
 510224                     // terminal: set the controlling terminal.
 510225                     //
 510226                     ps->device_tty = inode->direct[0];
 510227                     tty->pgrp      = ps->pgrp;
 510228                   }
 510229               }
 510230           }
 510231       }
 510232     //
 510233     // Return the file descriptor.
 510234     //
 510235     return (fdn);
 510236 }

 520001 #include <kernel/proc.h>
 520002 #include <kernel/k_libc.h>
 520003 #include <errno.h>
 520004 #include <fcntl.h>
 520005 //----------------------------------------------------------------------
 520006 ssize_t
 520007 fd_read (pid_t pid, int fdn, void *buffer, size_t count, int *eof)
 520008 {
 520009     fd_t  *fd;
 520010     ssize_t  size_read;
 520011     //
 520012     // Get file descriptor.
 520013     //
 520014     fd = fd_reference (pid, &fdn);
 520015     if (fd              == NULL   ||
 520016         fd->file        == NULL   ||
 520017         fd->file->inode == NULL )
 520018       {
 520019         errset (EBADF);                 // Bad file descriptor.
 520020         return ((ssize_t) -1);
 520021       }
 520022     //
 520023     // Check if it is opened for read.
 520024     //
 520025     if (!(fd->file->oflags & O_RDONLY))
 520026       {
 520027         //
 520028         // The file is not opened for read.
 520029         //
 520030         errset (EINVAL);                // Invalid argument.
 520031         return ((ssize_t) -1);
 520032       }
 520033     //
 520034     // It is not a mistake to read a directory, as `dirent.h' is
 520035     // implemented through file descriptors.
 520036     //
 520037     //  //
 520038     //  // Check if it is a directory.
 520039     //  //
 520040     //  if (fd->file->inode->mode & S_IFDIR)
 520041     //    {
 520042     //      errset (EISDIR);                // Is a directory.
 520043     //      return ((ssize_t) -1);
 520044     //    }
 520045     //
 520046     // Check the kind of file to be read and read it.
 520047     //
 520048     if  (S_ISBLK (fd->file->inode->mode)
 520049       || S_ISCHR (fd->file->inode->mode))
 520050       {
 520051         //
 520052         // A device is to be read.
 520053         //
 520054         size_read = dev_io (pid, (dev_t) fd->file->inode->direct[0],
 520055                             DEV_READ, fd->file->offset, buffer, count,
 520056                             eof);
 520057       }
 520058     else if (S_ISREG (fd->file->inode->mode))
 520059       {
 520060         //
 520061         // A regular file is to be read.
 520062         //
 520063         size_read = inode_file_read (fd->file->inode, fd->file->offset,
 520064                                      buffer, count, eof);
 520065       }
 520066     else if (S_ISDIR (fd->file->inode->mode))
 520067       {
 520068         //
 520069         // A directory, is to be read.
 520070         //
 520071         size_read = inode_file_read (fd->file->inode, fd->file->offset,
 520072                                      buffer, count, eof);
 520073       }
 520074     else
 520075       {
 520076         //
 520077         // Unsupported file type.
 520078         //
 520079         errset (E_FILE_TYPE_UNSUPPORTED);       //File type unsupported.
 520080         return ((ssize_t) -1);
 520081       }
 520082     //
 520083     // Update the file descriptor internal offset.
 520084     //
 520085     if (size_read > 0)
 520086       {
 520087         fd->file->offset += size_read;
 520088       }
 520089     //
 520090     // Just return the size read, even if it is an error. Please note
 520091     // that a size of zero might tell that it is the end of file, or
 520092     // just that the read should be retried.
 520093     //
 520094     return (size_read);
 520095 }

 530001 #include <kernel/proc.h>
 530002 #include <kernel/k_libc.h>
 530003 #include <errno.h>
 530004 //----------------------------------------------------------------------
 530005 fd_t *
 530006 fd_reference (pid_t pid, int *fdn)
 530007 {
 530008     proc_t *ps;
 530009     //
 530010     // Get process.
 530011     //
 530012     ps = proc_reference (pid);
 530013     //
 530014     // See what to do.
 530015     //
 530016     if (*fdn < 0)
 530017       {
 530018         //
 530019         // Find the first free slot.
 530020         //
 530021         for (*fdn = 0; *fdn < OPEN_MAX; (*fdn)++)
 530022           {
 530023             if (ps->fd[*fdn].file == NULL)
 530024               {
 530025                 return (&(ps->fd[*fdn]));
 530026               }
 530027           }
 530028         *fdn = -1;
 530029         return (NULL);
 530030       }
 530031     else
 530032       {
 530033         if (*fdn < OPEN_MAX)
 530034           {
 530035             //
 530036             // Might return even a free file descriptor.
 530037             //
 530038             return (&(ps->fd[*fdn]));
 530039           }
 530040         else
 530041           {
 530042             return (NULL);
 530043           }
 530044       }
 530045 }

 540001 #include <kernel/proc.h>
 540002 #include <kernel/k_libc.h>
 540003 #include <errno.h>
 540004 #include <fcntl.h>
 540005 //----------------------------------------------------------------------
 540006 int
 540007 fd_stat (pid_t pid, int fdn, struct stat *buffer)
 540008 {
 540009     proc_t   *ps;
 540010     inode_t  *inode;
 540011     //
 540012     // Get process.
 540013     //
 540014     ps = proc_reference (pid);
 540015     //
 540016     // Verify if the file descriptor is valid.
 540017     //
 540018     if (ps->fd[fdn].file == NULL)
 540019       {
 540020         errset (EBADF);                 // Bad file descriptor.
 540021         return (-1);
 540022       }
 540023     //
 540024     // Reach the inode.
 540025     //
 540026     inode = ps->fd[fdn].file->inode;
 540027     //
 540028     // Inode loaded: update the buffer.
 540029     //
 540030     buffer->st_dev      = inode->sb->device;
 540031     buffer->st_ino      = inode->ino;
 540032     buffer->st_mode     = inode->mode;
 540033     buffer->st_nlink    = inode->links;
 540034     buffer->st_uid      = inode->uid;
 540035     buffer->st_gid      = inode->gid;
 540036     if (S_ISBLK (buffer->st_mode) || S_ISCHR (buffer->st_mode))
 540037       {
 540038         buffer->st_rdev = inode->direct[0];
 540039       }
 540040     else
 540041       {
 540042         buffer->st_rdev = 0;
 540043       }
 540044     buffer->st_size     = inode->size;
 540045     buffer->st_atime    = inode->time;  // All times are the same for
 540046     buffer->st_mtime    = inode->time;  // Minix 1 file system.
 540047     buffer->st_ctime    = inode->time;  //
 540048     buffer->st_blksize  = inode->sb->blksize;
 540049     buffer->st_blocks   = inode->blkcnt;
 540050     //
 540051     // If the inode is a device special file, the `st_rdev' value is
 540052     // taken from the first direct zone (as of Minix 1 organization).
 540053     //
 540054     if (S_ISBLK(inode->mode) || S_ISCHR(inode->mode))
 540055       {
 540056         buffer->st_rdev = inode->direct[0];
 540057       }
 540058     else
 540059       {
 540060         buffer->st_rdev = 0;
 540061       }
 540062     //
 540063     // Return.
 540064     //
 540065     return (0);
 540066 }

 550001 #include <kernel/proc.h>
 550002 #include <kernel/k_libc.h>
 550003 #include <errno.h>
 550004 #include <fcntl.h>
 550005 //----------------------------------------------------------------------
 550006 ssize_t
 550007 fd_write (pid_t pid, int fdn, const void *buffer, size_t count)
 550008 {
 550009     proc_t  *ps;
 550010     fd_t    *fd;
 550011     ssize_t  size_written;
 550012     //
 550013     // Get process.
 550014     //
 550015     ps = proc_reference (pid);
 550016     //
 550017     // Get file descriptor.
 550018     //
 550019     fd = fd_reference (pid, &fdn);
 550020     if (fd              == NULL   ||
 550021         fd->file        == NULL   ||
 550022         fd->file->inode == NULL )
 550023       {
 550024         //
 550025         // The file descriptor pointer is not valid.
 550026         //
 550027         errset (EBADF);                 // Bad file descriptor.
 550028         return ((ssize_t) -1);
 550029       }
 550030     //
 550031     // Check if it is opened for write.
 550032     //
 550033     if (!(fd->file->oflags & O_WRONLY))
 550034       {
 550035         //
 550036         // The file is not opened for write.
 550037         //
 550038         errset (EINVAL);                // Invalid argument.
 550039         return ((ssize_t) -1);
 550040       }
 550041     //
 550042     // Check if it is a directory.
 550043     //
 550044     if (fd->file->inode->mode & S_IFDIR)
 550045       {
 550046         errset (EISDIR);                // Is a directory.
 550047         return ((ssize_t) -1);
 550048       }
 550049     //
 550050     // It should be a valid type of file to be written. Check if it is
 550051     // opened in append mode: if so, must move the write offset to the
 550052     // end.
 550053     //
 550054     if (fd->fl_flags & O_APPEND)
 550055       {
 550056         fd->file->offset = fd->file->inode->size;
 550057       }
 550058     //
 550059     // Check the kind of file to be written and write it.
 550060     //
 550061     if (fd->file->inode->mode & S_IFBLK ||
 550062         fd->file->inode->mode & S_IFCHR)
 550063       {
 550064         //
 550065         // A device is to be written.
 550066         //
 550067         size_written = dev_io (pid, (dev_t) fd->file->inode->direct[0],
 550068                                DEV_WRITE, fd->file->offset, buffer,
 550069                                count, NULL);
 550070       }
 550071     else if (fd->file->inode->mode & S_IFREG)
 550072       {
 550073         //
 550074         // A regular file is to be written.
 550075         //
 550076         size_written = inode_file_write (fd->file->inode,
 550077                                          fd->file->offset,
 550078                                          buffer, count);
 550079       }
 550080     else
 550081       {
 550082         //
 550083         // Unsupported file type.
 550084         //
 550085         errset (E_FILE_TYPE_UNSUPPORTED);       //File type unsupported.
 550086         return ((ssize_t) -1);
 550087       }
 550088     //
 550089     // Update the file descriptor internal offset.
 550090     //
 550091     if (size_written > 0)
 550092       {
 550093         fd->file->offset += size_written;
 550094       }
 550095     //
 550096     // Just return the size written, even if it is an error.
 550097     //
 550098     return (size_written);
 550099 }

 560001 #include <kernel/proc.h>
 560002 #include <errno.h>
 560003 #include <fcntl.h>
 560004 //----------------------------------------------------------------------
 560005 file_t *
 560006 file_reference (int fno)
 560007 {
 560008     //
 560009     // Check type of request.
 560010     //
 560011     if (fno < 0)
 560012       {
 560013         //
 560014         // Find a free slot.
 560015         //
 560016         for (fno = 0; fno < FILE_MAX_SLOTS; fno++)
 560017           {
 560018             if (file_table[fno].references <= 0)
 560019               {
 560020                 return (&file_table[fno]);
 560021               }
 560022           }
 560023         return (NULL);
 560024       }
 560025     else if (fno > FILE_MAX_SLOTS)
 560026       {
 560027         return (NULL);
 560028       }
 560029     else
 560030       {
 560031         return (&file_table[fno]);
 560032       }
 560033 }

 570001 #include <kernel/proc.h>
 570002 #include <errno.h>
 570003 #include <fcntl.h>
 570004 //----------------------------------------------------------------------
 570005 file_t *
 570006 file_stdio_dev_make (dev_t device, mode_t mode, int oflags)
 570007 {
 570008     inode_t *inode;
 570009     file_t  *file;
 570010     //
 570011     // Try to allocate a device inode.
 570012     //
 570013     inode = inode_stdio_dev_make (device, mode);
 570014     if (inode == NULL)
 570015       {
 570016         //
 570017         // Variable `errno' is already set by `inode_stdio_dev_make()'.
 570018         //
 570019         errset (errno);
 570020         return (NULL);
 570021       }
 570022     //
 570023     // Inode allocated: need to allocate the system file item.
 570024     //
 570025     file = file_reference (-1);
 570026     if (file == NULL)
 570027       {
 570028         //
 570029         // Remove the inode and return an error.
 570030         //
 570031         inode_put (inode);
 570032         errset (ENFILE);        // Too many files open in system.
 570033         return (NULL);
 570034       }
 570035     //
 570036     // Fill with data the system file item.
 570037     //
 570038     file->references = 1;
 570039     file->oflags     = (oflags & (O_RDONLY | O_WRONLY));
 570040     file->inode      = inode;
 570041     //
 570042     // Return system file pointer.
 570043     //
 570044     return (file);
 570045 }

 580001 #include <kernel/fs.h>
 580002 //----------------------------------------------------------------------
 580003 file_t file_table[FILE_MAX_SLOTS];
 580004 //----------------------------------------------------------------------

 590001 #include <kernel/fs.h>
 590002 #include <errno.h>
 590003 #include <kernel/k_libc.h>
 590004 //----------------------------------------------------------------------
 590005 inode_t *
 590006 inode_alloc (dev_t device, mode_t mode, uid_t uid)
 590007 {
 590008     sb_t        *sb;
 590009     inode_t     *inode;
 590010     int          m;                     // Index inside the inode map.
 590011     int          map_element;
 590012     int          map_bit;
 590013     int          map_mask;
 590014     ino_t        ino;
 590015     //
 590016     // Check for arguments.
 590017     //
 590018     if (mode == 0)
 590019       {
 590020         errset (EINVAL);        // Invalid argument.
 590021         return (NULL);
 590022       }
 590023     //
 590024     // Get the super block from the known device.
 590025     //
 590026     sb = sb_reference (device);
 590027     if (sb == NULL)
 590028       {
 590029         errset (ENODEV);        // No such device.
 590030         return (NULL);
 590031       }
 590032     //
 590033     // Find a free inode.
 590034     //
 590035     while (1)
 590036       {
 590037         //
 590038         // Scan the inode bit map, to find a free inode
 590039         // for new allocation.
 590040         //
 590041         for (m = 0; m < (SB_MAP_INODE_SIZE * 16); m++)
 590042           {
 590043             map_element = m / 16;
 590044             map_bit     = m % 16;
 590045             map_mask    = 1 << map_bit;
 590046             if (!(sb->map_inode[map_element] & map_mask))
 590047               {
 590048                 //
 590049                 // Found a free element: change the map to
 590050                 // allocate the inode.
 590051                 //
 590052                 sb->map_inode[map_element] |= map_mask;
 590053                 sb->changed = 1;
 590054                 ino = m;  // Found a free inode:
 590055                 break;          // exit the scan loop.
 590056               }
 590057           }
 590058         //
 590059         // Check if the scan was successful.
 590060         //
 590061         if (ino == 0)
 590062           {
 590063             errset (ENOSPC);    // No space left on device.
 590064             return (NULL);
 590065           }
 590066         //
 590067         // The inode was allocated inside the map in memory.
 590068         //
 590069         inode = inode_get (device, ino);
 590070         if (inode == NULL)
 590071           {
 590072             errset (ENFILE);    // Too many files open in system.
 590073             return (NULL);
 590074           }
 590075         //
 590076         // Verify if the inode is really free: if it isn't, must save
 590077         // it to disk.
 590078         //
 590079         if (inode->size > 0 || inode->links > 0)
 590080           {
 590081             //
 590082             // Strange: should not have a size! Check if there are even
 590083             // links. Please note that 255 links (that is -1) is to be
 590084             // considered a free inode, marked in a special way for some
 590085             // unknown reason. Currently, `LINK_MAX' is equal to 254,
 590086             // for that reason.
 590087             //
 590088             if (inode->links > 0 && inode->links < LINK_MAX)
 590089               {
 590090                 //
 590091                 // Tell something.
 590092                 //
 590093                 k_printf ("kernel alert: device %04x: "
 590094                           "found \"free\" inode %i "
 590095                           "that still has size %i "
 590096                           "and %i links!\n",
 590097                           device, ino, inode->size, inode->links);
 590098                 //
 590099                 // The inode must be set again to free, inside
 590100                 // the bit map.
 590101                 //
 590102                 map_element = ino / 16;
 590103                 map_bit     = ino % 16;
 590104                 map_mask    = 1 << map_bit;
 590105                 sb->map_inode[map_element] &= ~map_mask;
 590106                 sb->changed = 1;
 590107                 //
 590108                 // Try to fix: reset all to zero.
 590109                 //
 590110                 inode->mode      = 0;
 590111                 inode->uid       = 0;
 590112                 inode->gid       = 0;
 590113                 inode->time      = 0;
 590114                 inode->links     = 0;
 590115                 inode->size      = 0;
 590116                 inode->direct[0] = 0;
 590117                 inode->direct[1] = 0;
 590118                 inode->direct[2] = 0;
 590119                 inode->direct[3] = 0;
 590120                 inode->direct[4] = 0;
 590121                 inode->direct[5] = 0;
 590122                 inode->direct[6] = 0;
 590123                 inode->indirect1 = 0;
 590124                 inode->indirect2 = 0;
 590125                 inode->changed   = 1;
 590126                 //
 590127                 // Save fixed inode to disk.
 590128                 //
 590129                 inode_put (inode);
 590130                 continue;
 590131               }
 590132             else
 590133               {
 590134                 //
 590135                 // Truncate the inode, save and break.
 590136                 //
 590137                 inode_truncate (inode);
 590138                 inode_save (inode);
 590139                 break;
 590140               }
 590141           }
 590142         else
 590143           {
 590144             //
 590145             // Considering free the inode found.
 590146             //
 590147             break;
 590148           }
 590149       }
 590150     //
 590151     // Put data inside the inode.
 590152     //
 590153     inode->mode    = mode;
 590154     inode->uid     = uid;
 590155     inode->gid     = 0;
 590156     inode->size    = 0;
 590157     inode->time    = k_time (NULL);
 590158     inode->links   = 0;
 590159     inode->changed = 1;
 590160     //
 590161     // Save the inode.
 590162     //
 590163     inode_save (inode);
 590164     //
 590165     // Return the inode pointer.
 590166     //
 590167     return (inode);
 590168 }

 600001 #include <kernel/fs.h>
 600002 #include <errno.h>
 600003 #include <kernel/k_libc.h>
 600004 //----------------------------------------------------------------------
 600005 int
 600006 inode_check (inode_t *inode, mode_t type, int perm, uid_t uid)
 600007 {
 600008     //
 600009     // Ensure that the variable `type' has only the requested file type.
 600010     //
 600011     type = (type & S_IFMT);
 600012     //
 600013     // Check inode argument.
 600014     //
 600015     if (inode == NULL)
 600016       {
 600017         errset (EINVAL);        // Invalid argument.
 600018         return (-1);
 600019       }
 600020     //
 600021     // The inode is not NULL: verify that the inode is of a type
 600022     // allowed (the parameter `type' can hold more than one
 600023     // possibility).
 600024     //
 600025     if (!(inode->mode & type))
 600026       {
 600027         errset (E_FILE_TYPE);   // The file type is not
 600028         return (-1);            // the expected one.
 600029       }
 600030     //
 600031     // The file type is correct.
 600032     //
 600033     if (inode->uid != 0 && uid == 0)
 600034       {
 600035         return (0);             // The root user has all permissions.
 600036       }
 600037     //
 600038     // The user is not root or the inode is owned by root.
 600039     //
 600040     if (inode->uid == uid)
 600041       {
 600042         //
 600043         // The user own the inode and must check user permissions.
 600044         //
 600045         perm = (perm << 6);
 600046         if ((inode->mode & perm) ^ perm)
 600047           {
 600048             errset (EACCES);            // Permission denied.
 600049             return (-1);
 600050           }
 600051         else
 600052           {
 600053             return (0);
 600054           }
 600055       }
 600056     //
 600057     // The user does not own the inode: the other permissions are
 600058     // checked.
 600059     //
 600060     if ((inode->mode & perm) ^ perm)
 600061       {
 600062         errset (EACCES);                // Permission denied.
 600063         return (-1);
 600064       }
 600065     else
 600066       {
 600067         return (0);
 600068       }
 600069 }

 610001 #include <kernel/fs.h>
 610002 #include <errno.h>
 610003 #include <kernel/k_libc.h>
 610004 //----------------------------------------------------------------------
 610005 int
 610006 inode_dir_empty (inode_t *inode)
 610007 {
 610008     off_t        start;
 610009     char         buffer[SB_MAX_ZONE_SIZE];
 610010     directory_t *dir;
 610011     ssize_t      size_read;
 610012     int          d;                     // Directory buffer index.
 610013     //
 610014     // Check argument: must be a directory.
 610015     //
 610016     if (inode == NULL || !S_ISDIR (inode->mode))
 610017       {
 610018         errset (EINVAL);                // Invalid argument.
 610019         return (0);                     // false
 610020       }
 610021     //
 610022     // Read the directory content: if an item is present (except `.' and
 610023     // `..'), the directory is not empty.
 610024     //
 610025     for (start  = 0;
 610026          start <  inode->size;
 610027          start += inode->sb->blksize)
 610028       {
 610029         size_read = inode_file_read (inode, start, buffer,
 610030                                      inode->sb->blksize,
 610031                                      NULL);
 610032         if (size_read < sizeof (directory_t))
 610033           {
 610034             break;
 610035           }
 610036         //
 610037         // Scan the directory portion just read.
 610038         //
 610039         dir = (directory_t *) buffer;
 610040         //
 610041         for (d = 0; d < size_read; d += (sizeof (directory_t)), dir++)
 610042           {
 610043             if (dir->ino != 0                              &&
 610044                 strncmp (dir->name, ".", NAME_MAX) != 0    &&
 610045                 strncmp (dir->name, "..", NAME_MAX) != 0)
 610046               {
 610047                 //
 610048                 // There is an item and the directory is not empty.
 610049                 //
 610050                 return (0);     // false
 610051               }
 610052           }
 610053       }
 610054     //
 610055     // Nothing was found; good!
 610056     //
 610057     return (1);         // true
 610058 }

 620001 #include <kernel/fs.h>
 620002 #include <errno.h>
 620003 #include <kernel/k_libc.h>
 620004 //----------------------------------------------------------------------
 620005 ssize_t
 620006 inode_file_read (inode_t *inode, off_t offset,
 620007                  void *buffer, size_t count, int *eof)
 620008 {
 620009     unsigned char *destination = (unsigned char *) buffer;
 620010     unsigned char  zone_buffer[SB_MAX_ZONE_SIZE];
 620011     blkcnt_t       blkcnt_read;
 620012     off_t          off_fzone;   // File zone offset.
 620013     off_t          off_buffer;  // Destination buffer offset.
 620014     ssize_t        size_read;   // Byte transfer counter.
 620015     zno_t          fzone;
 620016     off_t          off_end;
 620017     //
 620018     // The inode pointer must be valid, and
 620019     // the start byte must be positive.
 620020     //
 620021     if (inode == NULL || offset < 0)
 620022       {
 620023         errset (EINVAL);        // Invalid argument.
 620024         return ((ssize_t) -1);
 620025       }
 620026     //
 620027     // Check if the start address is inside the file size. This is not
 620028     // an error, but zero bytes are read and `*eof' is set. Otherwise,
 620029     // `*eof' is reset.
 620030     //
 620031     if (offset >= inode->size)
 620032       {
 620033         (eof != NULL)? *eof = 1: 0;
 620034         return (0);
 620035       }
 620036     else
 620037       {
 620038         (eof != NULL)? *eof = 0: 0;
 620039       }
 620040     //
 620041     // Adjust, if necessary, the size of read, because it cannot be
 620042     // larger than the actual file size. The variable `off_end' is
 620043     // used to calculate the position *after* the requested read.
 620044     // Remember that the first file position is byte zero; so,
 620045     // the byte index inside the file goes from zero to inode->size -1.
 620046     //
 620047     off_end  = offset;
 620048     off_end += count;
 620049     if (off_end > inode->size)
 620050       {
 620051         count = (inode->size - offset);
 620052       }
 620053     //
 620054     // Read the first file-zone inside the zone buffer.
 620055     //
 620056     fzone       = offset / inode->sb->blksize;
 620057     off_fzone   = offset % inode->sb->blksize;
 620058     blkcnt_read = inode_fzones_read (inode, fzone, zone_buffer,
 620059                                      (blkcnt_t) 1);
 620060     if (blkcnt_read <= 0)
 620061       {
 620062         //
 620063         // Sorry!
 620064         //
 620065         return (0);                 // Zero bytes read!
 620066       }
 620067     //
 620068     // The first file-zone was read: copy it inside the destination
 620069     // buffer and continue reading the other zones needed. Variables
 620070     // `off_buffer' (destination buffer index) and `size_read' (copy
 620071     // byte counter) must be reset here. Variable `off_fzone' is already
 620072     // set with the initial offset inside `zone_buffer'.
 620073     //
 620074     off_buffer = 0;
 620075     size_read  = 0;
 620076     //
 620077     while (count)
 620078       {
 620079         //
 620080         // Copy the zone buffer into the destination. Variables
 620081         // `off_fzone', `off_buffer' and `size_read' must not be
 620082         // initialized inside the loop.
 620083         //
 620084         for (; off_fzone < inode->sb->blksize && count > 0;
 620085              off_fzone++, off_buffer++, size_read++,
 620086              count--, offset++)
 620087           {
 620088             destination[off_buffer] = zone_buffer[off_fzone];
 620089           }
 620090         //
 620091         // If not all the bytes are copied, read the next file-zone.
 620092         //
 620093         if (count)
 620094           {
 620095             //
 620096             // Read another file-zone inside the zone buffer.
 620097             // Again, the function `inode_fzones_read()' might
 620098             // return a null pointer, but the variable `errno' tells if
 620099             // it is really an error. For this reason, the variable
 620100             // `errno' must be reset before the read, and checked after
 620101             // it.
 620102             //
 620103             fzone       = offset / inode->sb->blksize;
 620104             off_fzone   = offset % inode->sb->blksize;
 620105             blkcnt_read = inode_fzones_read (inode, fzone, zone_buffer,
 620106                                              (blkcnt_t) 1);
 620107             if (blkcnt_read <= 0)
 620108               {
 620109                 //
 620110                 // Sorry: only `size_read' bytes read!
 620111                 //
 620112                 return (size_read);
 620113               }
 620114           }
 620115       }
 620116     //
 620117     // The requested size was read completely.
 620118     //
 620119     return (size_read);
 620120 }

 630001 #include <kernel/fs.h>
 630002 #include <errno.h>
 630003 #include <kernel/k_libc.h>
 630004 //----------------------------------------------------------------------
 630005 ssize_t
 630006 inode_file_write (inode_t *inode, off_t offset, void *buffer,
 630007                   size_t count)
 630008 {
 630009     unsigned char *buffer_source = (unsigned char *) buffer;
 630010     unsigned char  buffer_zone[SB_MAX_ZONE_SIZE];
 630011     off_t          off_fzone;    // File zone offset.
 630012     off_t          off_source;   // Source buffer offset.
 630013     ssize_t        size_copied;  // Byte transfer counter.
 630014     ssize_t        size_written; // Byte written counter.
 630015     zno_t          fzone;
 630016     zno_t          zone;
 630017     blkcnt_t       blkcnt_read;
 630018     int            status;
 630019     //
 630020     // The inode pointer must be valid, and
 630021     // the start byte must be positive.
 630022     //
 630023     if (inode == NULL || offset < 0)
 630024       {
 630025         errset (EINVAL);        // Invalid argument.
 630026         return ((ssize_t) -1);
 630027       }
 630028     //
 630029     // Read a zone, modify it with the source buffer, then write it back
 630030     // and continue reading and writing other zones if needed.
 630031     //
 630032     for (size_written = 0, off_source = 0, size_copied = 0;
 630033          count > 0; size_written += size_copied)
 630034       {
 630035         //
 630036         // Read the next file-zone inside the zone buffer: the function
 630037         // `inode_zone()' is used to create automatically the zone, if
 630038         // it does not exist.
 630039         //
 630040         fzone     = offset / inode->sb->blksize;
 630041         off_fzone = offset % inode->sb->blksize;
 630042         zone      = inode_zone (inode, fzone, 1);
 630043         if (zone == 0)
 630044           {
 630045             //
 630046             // Return previously written bytes. The variable `errno' is
 630047             // already set by `inode_zone()'.
 630048             //
 630049             return (size_written);
 630050           }
 630051         blkcnt_read = inode_fzones_read (inode, fzone, buffer_zone,
 630052                                          (blkcnt_t) 1);
 630053         if (blkcnt_read <= 0)
 630054           {
 630055             //
 630056             // Even if the value is zero, there is a problem reading the
 630057             // zone to be overwritten (because `inode_zone()' should
 630058             // have already created such zone). The variable `errno' is
 630059             // already set by `inode_fzones_read()'.
 630060             //
 630061             return ((ssize_t) -1);
 630062           }
 630063         //
 630064         // The zone was successfully loaded inside the buffer: overwrite
 630065         // the zone buffer with the source buffer.
 630066         //
 630067         for (size_copied = 0;
 630068              off_fzone < inode->sb->blksize && count > 0;
 630069              off_fzone++, off_source++, size_copied++, count--,
 630070              offset++)
 630071           {
 630072             buffer_zone[off_fzone] = buffer_source[off_source];
 630073           }
 630074         //
 630075         // Save the zone.
 630076         //
 630077         status = zone_write (inode->sb, zone, buffer_zone);
 630078         if (status != 0)
 630079           {
 630080             //
 630081             // Cannot save the zone: return the size already written.
 630082             // The variable `errno' is already set by `zone_write()'.
 630083             //
 630084             return (size_written);
 630085           }
 630086         //
 630087         // Zone saved: update the file size if necessary (and the inode
 630088         // too).
 630089         //
 630090         if (inode->size <= offset)
 630091           {
 630092             inode->size    = offset;
 630093             inode->changed = 1;
 630094             inode_save (inode);
 630095           }
 630096       }
 630097     //
 630098     // All done successfully: return the value.
 630099     //
 630100     return (size_written);
 630101 }

 640001 #include <kernel/fs.h>
 640002 #include <errno.h>
 640003 #include <kernel/k_libc.h>
 640004 //----------------------------------------------------------------------
 640005 int
 640006 inode_free (inode_t *inode)
 640007 {
 640008     int      map_element;
 640009     int      map_bit;
 640010     int      map_mask;
 640011     //
 640012     if (inode == NULL)
 640013       {
 640014         errset (EINVAL);        // Invalid argument.
 640015         return (-1);
 640016       }
 640017     //
 640018     map_element = inode->ino / 16;
 640019     map_bit     = inode->ino % 16;
 640020     map_mask    = 1 << map_bit;
 640021     //
 640022     if (inode->sb->map_inode[map_element] & map_mask)
 640023       {
 640024         inode->sb->map_inode[map_element] -= map_mask;
 640025         inode->sb->changed = 1;
 640026       }
 640027     //
 640028     inode->mode       = 0;
 640029     inode->uid        = 0;
 640030     inode->gid        = 0;
 640031     inode->size       = 0;
 640032     inode->time       = 0;
 640033     inode->links      = 0;
 640034     inode->changed    = 1;
 640035     inode->references = 0;
 640036     //
 640037     return (inode_save (inode));
 640038 }

 650001 #include <kernel/fs.h>
 650002 #include <errno.h>
 650003 #include <kernel/k_libc.h>
 650004 //----------------------------------------------------------------------
 650005 blkcnt_t
 650006 inode_fzones_read (inode_t *inode, zno_t zone_start,
 650007                    void *buffer, blkcnt_t blkcnt)
 650008 {
 650009     unsigned char *destination = (unsigned char *) buffer;
 650010     int            status;        // `zone_read()' return value.
 650011     blkcnt_t       blkcnt_read;   // Zone counter/index.
 650012     zno_t          zone;
 650013     zno_t          fzone;
 650014     //
 650015     // Read the zones into the destination buffer.
 650016     //
 650017     for (blkcnt_read = 0, fzone = zone_start;
 650018          blkcnt_read < blkcnt;
 650019          blkcnt_read++, fzone++)
 650020       {
 650021         //
 650022         // Calculate the zone number, from the file-zone, reading the
 650023         // inode. If a zone is not really allocated, the result is zero
 650024         // and is valid.
 650025         //
 650026         zone = inode_zone (inode, fzone, 0);
 650027         if (zone == ((zno_t) -1))
 650028           {
 650029             //
 650030             // This is an error. Return the read zones quantity.
 650031             //
 650032             return (blkcnt_read);
 650033           }
 650034         //
 650035         // Update the destination buffer pointer.
 650036         //
 650037         destination += (blkcnt_read * inode->sb->blksize);
 650038         //
 650039         // Read the zone inside the destination buffer, but if the zone
 650040         // is zero, a zeroed zone must be filled.
 650041         //
 650042         if (zone == 0)
 650043           {
 650044             memset (destination, 0, (size_t) inode->sb->blksize);
 650045           }
 650046         else
 650047           {
 650048             status = zone_read (inode->sb, zone, destination);
 650049             if (status != 0)
 650050               {
 650051                 //
 650052                 // Could not read the requested zone: return the zones
 650053                 // read correctly.
 650054                 //
 650055                 errset (EIO);               // I/O error.
 650056                 return (blkcnt_read);
 650057               }
 650058           }
 650059       }
 650060     //
 650061     // All zones read correctly inside the buffer.
 650062     //
 650063     return (blkcnt_read);
 650064 }

 660001 #include <kernel/fs.h>
 660002 #include <errno.h>
 660003 #include <kernel/k_libc.h>
 660004 //----------------------------------------------------------------------
 660005 blkcnt_t
 660006 inode_fzones_write (inode_t *inode, zno_t zone_start, void *buffer,
 660007                     blkcnt_t blkcnt)
 660008 {
 660009     unsigned char *source = (unsigned char *) buffer;
 660010     int            status;              // `zone_read()' return value.
 660011     blkcnt_t       blkcnt_written;      // Written zones counter.
 660012     zno_t          zone;
 660013     zno_t          fzone;
 660014     //
 660015     // Write the zones into the destination buffer.
 660016     //
 660017     for (blkcnt_written = 0, fzone = zone_start;
 660018          blkcnt_written < blkcnt;
 660019          blkcnt_written++, fzone++)
 660020       {
 660021         //
 660022         // Find real zone from file-zone.
 660023         //
 660024         zone = inode_zone (inode, fzone, 1);
 660025         if (zone == 0 || zone == ((zno_t) -1))
 660026           {
 660027             //
 660028             // Function `inode_zone()' should allocate automatically
 660029             // a missing zone and should return a valid zone or
 660030             // (zno_t) -1. Anyway, even if a zero zone is returned,
 660031             // it is an error. Return the `blkcnt_written' value.
 660032             //
 660033             return (blkcnt_written);
 660034           }
 660035         //
 660036         // Update the source buffer pointer for the next zone write.
 660037         //
 660038         source += (blkcnt_written * inode->sb->blksize);
 660039         //
 660040         // Write the zone from the buffer content.
 660041         //
 660042         status  = zone_write (inode->sb, zone, source);
 660043         if (status != 0)
 660044           {
 660045             //
 660046             // Cannot write the zone. Return `size_written_zone' value.
 660047             //
 660048             return (blkcnt_written);
 660049           }
 660050       }
 660051     //
 660052     // All zones read correctly inside the buffer.
 660053     //
 660054     return (blkcnt_written);
 660055 }

 670001 #include <kernel/fs.h>
 670002 #include <errno.h>
 670003 #include <kernel/k_libc.h>
 670004 #include <kernel/devices.h>
 670005 //----------------------------------------------------------------------
 670006 inode_t *
 670007 inode_get (dev_t device, ino_t ino)
 670008 {
 670009     sb_t             *sb;
 670010     inode_t          *inode;
 670011     unsigned long int start;
 670012     size_t            size;
 670013     ssize_t           n;
 670014     int               status;
 670015     //
 670016     // Verify if the root file system inode was requested.
 670017     //
 670018     if (device == 0 && ino == 1)
 670019       {
 670020         //
 670021         // Get root file system inode.
 670022         //
 670023         inode = inode_reference (device, ino);
 670024         if (inode == NULL)
 670025           {
 670026             //
 670027             // The file system root directory inode is not yet loaded:
 670028             // get the first super block.
 670029             //
 670030             sb = sb_reference ((dev_t) 0);
 670031             if (sb == NULL || sb->device == 0)
 670032               {
 670033                 //
 670034                 // This error should never happen.
 670035                 //
 670036                 errset (EUNKNOWN);      // Unknown error.
 670037                 return (NULL);
 670038               }
 670039             //
 670040             // Load the file system root directory inode (recursive
 670041             // call).
 670042             //
 670043             inode = inode_get (sb->device, (ino_t) 1);
 670044             if (inode == NULL)
 670045               {
 670046                 //
 670047                 // This error should never happen.
 670048                 //
 670049                 return (NULL);
 670050               }
 670051             //
 670052             // Return the directory inode.
 670053             //
 670054             return (inode);
 670055           }
 670056         else
 670057           {
 670058             //
 670059             // The file system root directory inode is already
 670060             // available.
 670061             //
 670062             if (inode->references >= INODE_MAX_REFERENCES)
 670063               {
 670064                 errset (ENFILE); // Too many files open in system.
 670065                 return (NULL);
 670066               }
 670067             else
 670068               {
 670069                 inode->references++;
 670070                 return (inode);
 670071               }
 670072           }
 670073       }
 670074     //
 670075     // A common device-inode pair was requested: try to find an already
 670076     // cached inode.
 670077     //
 670078     inode = inode_reference (device, ino);
 670079     if (inode != NULL)
 670080       {
 670081         if (inode->references >= INODE_MAX_REFERENCES)
 670082           {
 670083             errset (ENFILE);    // Too many files open in system.
 670084             return (NULL);
 670085           }
 670086         else
 670087           {
 670088             inode->references++;
 670089             return (inode);
 670090           }
 670091       }
 670092     //
 670093     // The inode is not yet available: get super block.
 670094     //
 670095     sb = sb_reference (device);
 670096     if (sb == NULL)
 670097       {
 670098         errset (ENODEV);        // No such device.
 670099         return (NULL);
 670100       }
 670101     //
 670102     // The super block is available, but the inode is not yet cached.
 670103     // Verify if the inode map reports it as allocated.
 670104     //
 670105     status = sb_inode_status (sb, ino);
 670106     if (!status)
 670107       {
 670108         //
 670109         // The inode is not allocated and cannot be loaded.
 670110         //
 670111         errset (ENOENT);        // No such file or directory.
 670112         return (NULL);
 670113       }
 670114     //
 670115     // The inode was not already cached, but is considered as allocated
 670116     // inside the inode map. Find a free slot to load the inode inside
 670117     // the inode table (in memory).
 670118     //
 670119     inode = inode_reference ((dev_t) -1, (ino_t) -1);
 670120     if (inode == NULL)
 670121       {
 670122         errset (ENFILE);        // Too many files open in system.
 670123         return (NULL);
 670124       }
 670125     //
 670126     // A free inode slot was found. The inode must be loaded.
 670127     // Calculate the memory inode size, to be saved inside the file
 670128     // system: the administrative inode data, as it is saved inside
 670129     // the file system. The `inode_t' type is bigger than the real
 670130     // inode administrative size, because it contains more data, that is
 670131     // not saved on disk.
 670132     //
 670133     size   = offsetof (inode_t, sb);
 670134     //
 670135     // Calculating start position for read.
 670136     //
 670137     // [1] Boot block.
 670138     // [2] Super block.
 670139     // [3] Inode bit map.
 670140     // [4] Zone bit map.
 670141     // [5] Previous inodes: consider that the inode zero is
 670142     //     present in the inode map, but not in the inode
 670143     //     table.
 670144     //
 670145     start  = 1024;                           // [1]
 670146     start += 1024;                           // [2]
 670147     start += (sb->map_inode_blocks * 1024);  // [3]
 670148     start += (sb->map_zone_blocks * 1024);   // [4]
 670149     start += ((ino -1) * size);              // [5]
 670150     //
 670151     // Read inode from disk.
 670152     //
 670153     n = dev_io ((pid_t) -1, device, DEV_READ, start, inode, size, NULL);
 670154     if (n != size)
 670155       {
 670156         errset (EIO);                   // I/O error.
 670157         return (NULL);
 670158       }
 670159     //
 670160     // The inode was read: add some data to the working copy in memory.
 670161     //
 670162     inode->sb            = sb;
 670163     inode->sb_attached   = NULL;
 670164     inode->ino           = ino;
 670165     inode->references    = 1;
 670166     inode->changed       = 0;
 670167     //
 670168     inode->blkcnt        = inode->size;
 670169     inode->blkcnt       /= sb->blksize;
 670170     if (inode->size % sb->blksize)
 670171       {
 670172         inode->blkcnt++;
 670173       }
 670174     //
 670175     // Return the inode pointer.
 670176     //
 670177     return (inode);
 670178 }

 680001 #include <kernel/fs.h>
 680002 #include <errno.h>
 680003 #include <kernel/k_libc.h>
 680004 //----------------------------------------------------------------------
 680005 int
 680006 inode_put (inode_t *inode)
 680007 {
 680008     int        status;
 680009     //
 680010     // Check for valid argument.
 680011     //
 680012     if (inode == NULL)
 680013       {
 680014         errset (EINVAL);                // Invalid argument.
 680015         return (-1);
 680016       }
 680017     //
 680018     // Check for valid references.
 680019     //
 680020     if (inode->references <= 0)
 680021       {
 680022         errset (EUNKNOWN);              // Cannot put an inode with
 680023         return (-1);                    // zero or negative references.
 680024       }
 680025     //
 680026     // Debug.
 680027     //
 680028     if (inode->sb->device == 0 && inode->ino != 0)
 680029       {
 680030         k_printf ("kernel alert: trying to close inode with device "
 680031                   "zero, but a number different than zero!\n");
 680032         errset (EUNKNOWN);              // Cannot put an inode with
 680033         return (-1);                    // zero or negative references.
 680034       }
 680035     //
 680036     // There is at least one reference: now the references value is
 680037     // reduced.
 680038     //
 680039     inode->references--;
 680040     inode->changed = 1;
 680041     //
 680042     // If `inode->ino' is zero, it means that the inode was created in
 680043     // memory, but there is no file system for it. For example, it might
 680044     // be a standard I/O inode create automatically for a process.
 680045     // Inodes with number zero cannot be removed from a file system.
 680046     //
 680047     if (inode->ino == 0)
 680048       {
 680049         //
 680050         // Nothing to do: just return.
 680051         //
 680052         return (0);
 680053       }
 680054     //
 680055     //  References counter might be zero.
 680056     //
 680057     if (inode->references == 0)
 680058       {
 680059         //
 680060         // Check if the inode is to be deleted (until there are
 680061         // run time references, the inode cannot be removed).
 680062         //
 680063         if (inode->links == 0
 680064          || (S_ISDIR (inode->mode) && inode->links == 1))
 680065           {
 680066             //
 680067             // The inode has no more run time references and file system
 680068             // links are also zero (or one for a directory): remove it!
 680069             //
 680070             status = inode_truncate (inode);
 680071             if (status != 0)
 680072               {
 680073                 k_perror (NULL);
 680074               }
 680075             //
 680076             inode_free (inode);
 680077             return (0);
 680078           }
 680079       }
 680080     //
 680081     // Save inode to disk and return.
 680082     //
 680083     return (inode_save (inode));
 680084 }

 690001 #include <kernel/fs.h>
 690002 #include <errno.h>
 690003 #include <kernel/k_libc.h>
 690004 //----------------------------------------------------------------------
 690005 inode_t *
 690006 inode_reference (dev_t device, ino_t ino)
 690007 {
 690008     int   s;                            // Slot index.
 690009     sb_t *sb_table = sb_reference (0);
 690010     //
 690011     // If device is zero, and inode is zero, a reference to the whole
 690012     // table is returned.
 690013     //
 690014     if (device == 0 && ino == 0)
 690015       {
 690016         return (inode_table);
 690017       }
 690018     //
 690019     // If device is ((dev_t) -1) and the inode is ((ino_t) -1), a
 690020     // reference to a free inode slot is returned.
 690021     //
 690022     if (device == (dev_t) -1 && ino == ((ino_t) -1))
 690023       {
 690024         for (s = 0; s < INODE_MAX_SLOTS; s++)
 690025           {
 690026             if (inode_table[s].references == 0)
 690027               {
 690028                 return (&inode_table[s]);
 690029               }
 690030           }
 690031         return (NULL);
 690032       }
 690033     //
 690034     // If device is zero and the inode is 1, a reference to the root
 690035     // directory inode is returned.
 690036     //
 690037     if (device == 0 && ino == 1)
 690038       {
 690039         //
 690040         // The super block table is to be scanned.
 690041         //
 690042         for (device = 0, s = 0; s < SB_MAX_SLOTS; s++)
 690043           {
 690044             if (sb_table[s].device != 0                 &&
 690045                 sb_table[s].inode_mounted_on == NULL)
 690046               {
 690047                 device = sb_table[s].device;
 690048                 break;
 690049               }
 690050           }
 690051         if (device == 0)
 690052           {
 690053             errset (E_CANNOT_FIND_ROOT_DEVICE);
 690054             return (NULL);
 690055           }
 690056         //
 690057         // Scan the inode table to find inode 1 and the same device.
 690058         //
 690059         for (s = 0; s < INODE_MAX_SLOTS; s++)
 690060           {
 690061             if (inode_table[s].sb->device == device     &&
 690062                 inode_table[s].ino == 1)
 690063               {
 690064                 return (&inode_table[s]);
 690065               }
 690066           }
 690067         //
 690068         // Cannot find a root file system inode.
 690069         //
 690070         errset (E_CANNOT_FIND_ROOT_INODE);
 690071         return (NULL);
 690072       }
 690073     //
 690074     // A device and an inode number were selected: find the inode
 690075     // associated to it.
 690076     //
 690077     for (s = 0; s < INODE_MAX_SLOTS; s++)
 690078       {
 690079         if (inode_table[s].sb->device == device &&
 690080             inode_table[s].ino == ino)
 690081           {
 690082             return (&inode_table[s]);
 690083           }
 690084       }
 690085     //
 690086     // The inode was not found.
 690087     //
 690088     return (NULL);
 690089 }

 700001 #include <kernel/fs.h>
 700002 #include <errno.h>
 700003 #include <kernel/k_libc.h>
 700004 #include <kernel/devices.h>
 700005 //----------------------------------------------------------------------
 700006 int
 700007 inode_save (inode_t *inode)
 700008 {
 700009     size_t            size;
 700010     unsigned long int start;
 700011     ssize_t           n;
 700012     //
 700013     // Check for valid argument.
 700014     //
 700015     if (inode == NULL)
 700016       {
 700017         errset (EINVAL);                // Invalid argument.
 700018         return (-1);
 700019       }
 700020     //
 700021     // If the inode number is zero, no file system is involved!
 700022     //
 700023     if (inode->ino == 0)
 700024       {
 700025         return (0);
 700026       }
 700027     //
 700028     // Save the super block to disk.
 700029     //
 700030     sb_save (inode->sb);
 700031     //
 700032     // Save the inode to disk.
 700033     //
 700034     if (inode->changed)
 700035       {
 700036         size   = offsetof (inode_t, sb);
 700037         //
 700038         // Calculating start position for write.
 700039         //
 700040         // [1] Boot block.
 700041         // [2] Super block.
 700042         // [3] Inode bit map.
 700043         // [4] Zone bit map.
 700044         // [5] Previous inodes: consider that the inode zero is
 700045         //     present in the inode map, but not in the inode
 700046         //     table.
 700047         //
 700048         start  = 1024;                                  // [1]
 700049         start += 1024;                                  // [2]
 700050         start += (inode->sb->map_inode_blocks * 1024);  // [3]
 700051         start += (inode->sb->map_zone_blocks * 1024);   // [4]
 700052         start += ((inode->ino -1) * size);              // [5]
 700053         //
 700054         // Write the inode.
 700055         //
 700056         n = dev_io ((pid_t) -1, inode->sb->device, DEV_WRITE, start,
 700057                     inode, size, NULL);
 700058         //
 700059         inode->changed = 0;
 700060       }
 700061     return (0);
 700062 }

 710001 #include <kernel/fs.h>
 710002 #include <errno.h>
 710003 #include <kernel/k_libc.h>
 710004 //----------------------------------------------------------------------
 710005 inode_t *
 710006 inode_stdio_dev_make (dev_t device, mode_t mode)
 710007 {
 710008     inode_t     *inode;
 710009     //
 710010     // Check for arguments.
 710011     //
 710012     if (mode == 0 || device == 0)
 710013       {
 710014         errset (EINVAL);        // Invalid argument.
 710015         return (NULL);
 710016       }
 710017     //
 710018     // Find a free inode.
 710019     //
 710020     inode = inode_reference ((dev_t) -1, (ino_t) -1);
 710021     if (inode == NULL)
 710022       {
 710023         //
 710024         // No free slot available.
 710025         //
 710026         errset (ENFILE);        // Too many files open in system.
 710027         return (NULL);
 710028       }
 710029     //
 710030     // Put data inside the inode. Please note that `inode->ino' must be
 710031     // zero, because it is necessary to recognize it as an internal
 710032     // inode with no file system. Otherwise, with a value different than
 710033     // zero, `inode_put()' will try to remove it. [*]
 710034     //
 710035     inode->mode          = mode;
 710036     inode->uid           = 0;
 710037     inode->gid           = 0;
 710038     inode->size          = 0;
 710039     inode->time          = k_time (NULL);
 710040     inode->links         = 0;
 710041     inode->direct[0]     = device;
 710042     inode->direct[1]     = 0;
 710043     inode->direct[2]     = 0;
 710044     inode->direct[3]     = 0;
 710045     inode->direct[4]     = 0;
 710046     inode->direct[5]     = 0;
 710047     inode->direct[6]     = 0;
 710048     inode->indirect1     = 0;
 710049     inode->indirect2     = 0;
 710050     inode->sb_attached   = NULL;
 710051     inode->sb            = 0;
 710052     inode->ino           = 0;   // Must be zero. [*]
 710053     inode->blkcnt        = 0;
 710054     inode->references    = 1;
 710055     inode->changed       = 0;
 710056     //
 710057     // Add all access permissions.
 710058     //
 710059     inode->mode       |= (S_IRWXU|S_IRWXG|S_IRWXO);
 710060     //
 710061     // Return the inode pointer.
 710062     //
 710063     return (inode);
 710064 }

 720001 #include <kernel/fs.h>
 720002 //----------------------------------------------------------------------
 720003 inode_t inode_table[INODE_MAX_SLOTS];

 730001 #include <kernel/fs.h>
 730002 #include <errno.h>
 730003 #include <kernel/k_libc.h>
 730004 //----------------------------------------------------------------------
 730005 int
 730006 inode_truncate (inode_t *inode)
 730007 {
 730008   unsigned int indirect_zones;
 730009   zno_t        zone_table1[INODE_MAX_INDIRECT_ZONES];
 730010   zno_t        zone_table2[INODE_MAX_INDIRECT_ZONES];
 730011   unsigned int i;             // Direct index.
 730012   unsigned int i0;            // Single indirect index.
 730013   unsigned int i1;            // Double indirect first index.
 730014   unsigned int i2;            // Double indirect second index.
 730015   int          status;        // `zone_read()' return value.
 730016   //
 730017   // Calculate how many indirect zone numbers are stored inside
 730018   // a zone: it depends on the zone size.
 730019   //
 730020   indirect_zones  = inode->sb->blksize / 2;
 730021   //
 730022   // Scan and release direct zones. Errors are ignored.
 730023   //
 730024   for (i = 0; i < 7; i++)
 730025     {
 730026       zone_free (inode->sb, inode->direct[i]);
 730027       inode->direct[i] = 0;
 730028     }
 730029   //
 730030   // Scan single indirect zones, if present.
 730031   //
 730032   if (inode->blkcnt > 7 && inode->indirect1 != 0)
 730033     {
 730034       //
 730035       // There is a single indirect table to load. Errors are
 730036       // almost ignored.
 730037       //
 730038       status = zone_read (inode->sb, inode->indirect1, zone_table1);
 730039       if (status == 0)
 730040         {
 730041           //
 730042           // Scan the table and remove zones.
 730043           //
 730044           for (i0 = 0; i0 < indirect_zones; i0++)
 730045             {
 730046               zone_free (inode->sb, zone_table1[i0]);
 730047             }
 730048         }
 730049       //
 730050       // Remove indirect table too.
 730051       //
 730052       zone_free (inode->sb, inode->indirect1);
 730053       //
 730054       // Clear single indirect reference inside the inode.
 730055       //
 730056       inode->indirect1 = 0;
 730057     }
 730058   //
 730059   // Scan double indirect zones, if present.
 730060   //
 730061   if (   inode->blkcnt > (7+indirect_zones)
 730062       && inode->indirect2 != 0)
 730063     {
 730064       //
 730065       // There is a double indirect table to load. Errors are
 730066       // almost ignored.
 730067       //
 730068       status = zone_read (inode->sb, inode->indirect2, zone_table1);
 730069       if (status == 0)
 730070         {
 730071           //
 730072           // Scan the table and get second level indirection.
 730073           //
 730074           for (i1 = 0; i1 < indirect_zones; i1++)
 730075             {
 730076               if ((inode->blkcnt > (7+indirect_zones+indirect_zones*i1))
 730077                   && zone_table1[i1] != 0)
 730078                 {
 730079                   //
 730080                   // There is a second level table to load.
 730081                   //
 730082                   status = zone_read (inode->sb, zone_table1[i1],
 730083                                       zone_table2);
 730084                   if (status == 0)
 730085                     {
 730086                       //
 730087                       // Release zones.
 730088                       //
 730089                       for (i2 = 0;
 730090                            i2 < indirect_zones &&
 730091   (inode->blkcnt > (7+indirect_zones+indirect_zones*i1+i2));
 730092                            i2++)
 730093                         {
 730094                           zone_free (inode->sb, zone_table2[i2]);
 730095                         }
 730096                       //
 730097                       // Remove second level indirect table.
 730098                       //
 730099                       zone_free (inode->sb, zone_table1[i1]);
 730100                     }
 730101                 }
 730102             }
 730103           //
 730104           // Remove first level indirect table.
 730105           //
 730106           zone_free (inode->sb, inode->indirect2);
 730107         }
 730108       //
 730109       // Clear single indirect reference inside the inode.
 730110       //
 730111       inode->indirect2 = 0;
 730112     }
 730113   //
 730114   // Update super block and inode data.
 730115   //
 730116   sb_save (inode->sb);
 730117   inode->size = 0;
 730118   inode->changed = 1;
 730119   inode_save (inode);
 730120   //
 730121   // Successful return.
 730122   //
 730123   return (0);
 730124 }

 740001 #include <kernel/fs.h>
 740002 #include <errno.h>
 740003 #include <kernel/k_libc.h>
 740004 //----------------------------------------------------------------------
 740005 zno_t
 740006 inode_zone (inode_t *inode, zno_t fzone, int write)
 740007 {
 740008   unsigned int indirect_zones;
 740009   unsigned int allocated_zone;
 740010   zno_t        zone_table[INODE_MAX_INDIRECT_ZONES];
 740011   char         buffer[SB_MAX_ZONE_SIZE];
 740012   unsigned int i0;            // Single indirect index.     
 740013   unsigned int i1;            // Double indirect first index.
 740014   unsigned int i2;            // Double indirect second index.
 740015   int          status;
 740016   zno_t        zone_second;   // Second level table zone.
 740017   //
 740018   // Calculate how many indirect zone numbers are stored inside
 740019   // a zone: it depends on the zone size.
 740020   //
 740021   indirect_zones  = inode->sb->blksize / 2;
 740022   //
 740023   // Convert file-zone number into a zone number.
 740024   //
 740025   if (fzone < 7)
 740026     {
 740027       //
 740028       // 0 <= fzone <= 6
 740029       // The zone number is inside the direct zone references.
 740030       // Verify to have such zone.
 740031       //
 740032       if (inode->direct[fzone] == 0)
 740033         {
 740034           //
 740035           // There is not such zone, but we do not consider
 740036           // it an error, because a file can be not contiguous.
 740037           //
 740038           if (!write)
 740039             {
 740040               return ((zno_t) 0);
 740041             }
 740042           //
 740043           // Must be allocated.
 740044           //
 740045           allocated_zone = zone_alloc (inode->sb);
 740046           if (allocated_zone == 0)
 740047             {
 740048               //
 740049               // Cannot allocate the zone. The variable `errno' is
 740050               // set by `zone_alloc()'.
 740051               //
 740052               return ((zno_t) -1);
 740053             }
 740054           //
 740055           // The zone is allocated: clear the zone and save.
 740056           //
 740057           memset (buffer, 0, SB_MAX_ZONE_SIZE);
 740058           status = zone_write (inode->sb, allocated_zone, buffer);
 740059           if (status < 0)
 740060             {
 740061               //
 740062               // Cannot overwrite the zone. The variable `errno' is
 740063               // set by `zone_write()'.
 740064               //
 740065               return ((zno_t) -1);
 740066             }
 740067           //
 740068           // The zone is allocated and cleared: save the inode.
 740069           //
 740070           inode->direct[fzone] = allocated_zone;
 740071           inode->changed = 1;
 740072           status = inode_save (inode);
 740073           if (status != 0)
 740074             {
 740075               //
 740076               // Cannot save the inode. The variable `errno' is
 740077               // set `inode_save()'.
 740078               //
 740079               return ((zno_t) -1);
 740080             }
 740081         }
 740082       //
 740083       // The zone is there: return it.
 740084       //
 740085       return (inode->direct[fzone]);
 740086     }
 740087   if (fzone < 7 + indirect_zones)
 740088     {
 740089       //
 740090       // 7 <= fzone <= (6 + indirect_zones)
 740091       // The zone number is inside the single indirect zone
 740092       // references: verify to have the indirect zone table.
 740093       //
 740094       if (inode->indirect1 == 0)
 740095         {
 740096           //
 740097           // There is not such zone, but it is not an error.
 740098           //
 740099           if (!write)
 740100             {
 740101               return ((zno_t) 0);
 740102             }
 740103           //
 740104           // The first level of indirection must be initialized.
 740105           //
 740106           allocated_zone = zone_alloc (inode->sb);
 740107           if (allocated_zone == 0)
 740108             {
 740109               //
 740110               // Cannot allocate the zone for the indirection table:
 740111               // this is an error and the `errno' value is produced
 740112               // by `zone_alloc()'.
 740113               //
 740114               return ((zno_t) -1);
 740115             }
 740116           //
 740117           // The zone for the indirection table is allocated:
 740118           // clear the zone and save.
 740119           //
 740120           memset (buffer, 0, SB_MAX_ZONE_SIZE);
 740121           status = zone_write (inode->sb, allocated_zone, buffer);
 740122           if (status < 0)
 740123             {
 740124               //
 740125               // Cannot overwrite the zone. The variable `errno' is
 740126               // set by `zone_write()'.
 740127               //
 740128               return ((zno_t) -1);
 740129             }
 740130           //
 740131           // The indirection table zone is allocated and cleared:
 740132           // save the inode.
 740133           //
 740134           inode->indirect1 = allocated_zone;
 740135           inode->changed = 1;
 740136           status = inode_save (inode);
 740137           if (status != 0)
 740138             {
 740139               //
 740140               // Cannot save the inode. This is an error and the value
 740141               // for `errno' is produced by `inode_save()'.
 740142               //
 740143               return ((zno_t) -1);
 740144             }
 740145         }
 740146       //
 740147       // An indirect table is present inside the file system:
 740148       // load it.
 740149       //
 740150       status = zone_read (inode->sb, inode->indirect1, zone_table);
 740151       if (status != 0)
 740152         {
 740153           //
 740154           // Cannot load the indirect table. This is an error and the
 740155           // value for `errno' is assigned by function `zone_read()'.
 740156           //
 740157           return ((zno_t) -1);
 740158         }
 740159       //
 740160       // The indirect table was read. Calculate the index inside
 740161       // the table, for the requested zone.
 740162       //      
 740163       i0 = (fzone - 7);
 740164       //
 740165       // Check if the zone is to be allocated.
 740166       //
 740167       if (zone_table[i0] == 0)
 740168         {
 740169           //
 740170           // There is not such zone, but it is not an error.
 740171           //
 740172           if (!write)
 740173             {
 740174               return ((zno_t) 0);
 740175             }
 740176           //
 740177           // The zone must be allocated.
 740178           //
 740179           allocated_zone = zone_alloc (inode->sb);
 740180           if (allocated_zone == 0)
 740181             {
 740182               //
 740183               // There is no space for the zone allocation. The
 740184               // variable `errno' is already updated by
 740185               // `zone_alloc()'.
 740186               //
 740187               return ((zno_t) -1);
 740188             }
 740189           //
 740190           // The zone is allocated: clear the zone and save.
 740191           //
 740192           memset (buffer, 0, SB_MAX_ZONE_SIZE);
 740193           status = zone_write (inode->sb, allocated_zone, buffer);
 740194           if (status < 0)
 740195             {
 740196               //
 740197               // Cannot overwrite the zone. The variable `errno' is
 740198               // set by `zone_write()'.
 740199               //
 740200               return ((zno_t) -1);
 740201             }
 740202           //
 740203           // The zone is allocated and cleared: update the indirect
 740204           // zone table an save it. The inode is not modified,
 740205           // because the indirect table is outside.
 740206           //
 740207           zone_table[i0] = allocated_zone;
 740208           status = zone_write (inode->sb, inode->indirect1, zone_table);
 740209           if (status != 0)
 740210             {
 740211               //
 740212               // Cannot save the zone. The variable `errno' is already
 740213               // set by `zone_write()'.
 740214               //
 740215               return ((zno_t) -1);
 740216             }
 740217         }
 740218       //
 740219       // The zone is allocated.
 740220       //
 740221       return (zone_table[i0]);
 740222     }
 740223   else
 740224     {
 740225       //
 740226       // (7 + indirect_zones) <= fzone
 740227       // The zone number is inside the double indirect zone
 740228       // references.
 740229       // Verify to have the first level of second indirection.
 740230       //
 740231       if (inode->indirect2 == 0)
 740232         {
 740233           //
 740234           // There is not such zone, but it is not an error.
 740235           //
 740236           if (!write)
 740237             {
 740238               return ((zno_t) 0);
 740239             }
 740240           //
 740241           // The first level of second indirection must be
 740242           // initialized.
 740243           //
 740244           allocated_zone = zone_alloc (inode->sb);
 740245           if (allocated_zone == 0)
 740246             {
 740247               //
 740248               // Cannot allocate the zone. The variable `errno' is
 740249               // set by `zone_alloc()'.
 740250               //
 740251               return ((zno_t) -1);
 740252             }
 740253           //
 740254           // The zone for the indirection table is allocated:
 740255           // clear the zone and save.
 740256           //
 740257           memset (buffer, 0, SB_MAX_ZONE_SIZE);
 740258           status = zone_write (inode->sb, allocated_zone, buffer);
 740259           if (status < 0)
 740260             {
 740261               //
 740262               // Cannot overwrite the zone. The variable `errno' is
 740263               // set by `zone_write()'.
 740264               //
 740265               return ((zno_t) -1);
 740266             }
 740267           //
 740268           // The zone for the indirection table is allocated and
 740269           // cleared: save the inode.
 740270           //
 740271           inode->indirect2 = allocated_zone;
 740272           inode->changed = 1;
 740273           status = inode_save (inode);
 740274           if (status != 0)
 740275             {
 740276               //
 740277               // Cannot save the inode. The variable `errno' is
 740278               // set by `inode_save()'.
 740279               //
 740280               return ((zno_t) -1);
 740281             }
 740282         }
 740283       //
 740284       // The first level of second indirection is present:
 740285       // Read the second indirect table.
 740286       //
 740287       status = zone_read (inode->sb, inode->indirect2, zone_table);
 740288       if (status != 0)
 740289         {
 740290           //
 740291           // Cannot read the second indirect table. The variable
 740292           // `errno' is set by `zone_read()'.
 740293           //
 740294           return ((zno_t) -1);
 740295         }
 740296       //
 740297       // The first double indirect table was read: calculate
 740298       // indexes inside first and second level of table.
 740299       //
 740300       fzone -= 7;
 740301       fzone -= indirect_zones;
 740302       i1     = fzone / indirect_zones;
 740303       i2     = fzone % indirect_zones;
 740304       //
 740305       // Verify to have a second level.
 740306       //
 740307       if (zone_table[i1] == 0)
 740308         {
 740309           //
 740310           // There is not such zone, but it is not an error.
 740311           //
 740312           if (!write)
 740313             {
 740314               return ((zno_t) 0);
 740315             }
 740316           //
 740317           // The second level must be initialized.
 740318           //
 740319           allocated_zone = zone_alloc (inode->sb);
 740320           if (allocated_zone == 0)
 740321             {
 740322               //
 740323               // Cannot allocate the zone. The variable `errno' is set
 740324               // by `zone_alloc()'.
 740325               //
 740326               return ((zno_t) -1);
 740327             }
 740328           //
 740329           // The zone for the indirection table is allocated:
 740330           // clear the zone and save.
 740331           //
 740332           memset (buffer, 0, SB_MAX_ZONE_SIZE);
 740333           status = zone_write (inode->sb, allocated_zone, buffer);
 740334           if (status < 0)
 740335             {
 740336               //
 740337               // Cannot overwrite the zone. The variable `errno' is
 740338               // set by `zone_write()'.
 740339               //
 740340               return ((zno_t) -1);
 740341             }
 740342           //
 740343           // Update the first level index and save it.
 740344           //
 740345           zone_table[i1] = allocated_zone;
 740346           status = zone_write (inode->sb, inode->indirect2, zone_table);
 740347           if (status != 0)
 740348             {
 740349               //
 740350               // Cannot write the zone. The variable `errno' is set
 740351               // by `zone_write()'.
 740352               //
 740353               return ((zno_t) -1);
 740354             }
 740355         }
 740356       //
 740357       // The second level can be read, overwriting the array
 740358       // `zone_table[]'. The zone number for the second level
 740359       // indirection table is saved inside `zone_second', before
 740360       // overwriting the array.
 740361       //
 740362       zone_second = zone_table[i1];
 740363       status = zone_read (inode->sb, zone_second, zone_table);
 740364       if (status != 0)
 740365         {
 740366           //
 740367           // Cannot read the second level indirect table. The variable
 740368           // `errno' is set by `zone_read()'.
 740369           //
 740370           return ((zno_t) -1);
 740371         }
 740372       //
 740373       // The second level was read and `zone_table[]' is now
 740374       // such second one: check if the zone is to be allocated.
 740375       //
 740376       if (zone_table[i2] == 0)
 740377         {
 740378           //
 740379           // There is not such zone, but it is not an error.
 740380           //
 740381           if (!write)
 740382             {
 740383               return ((zno_t) 0);
 740384             }
 740385           //
 740386           // Must be allocated.
 740387           //
 740388           allocated_zone = zone_alloc (inode->sb);
 740389           if (allocated_zone == 0)
 740390             {
 740391               //
 740392               // Cannot allocate the zone. The variable `errno' is set
 740393               // by `zone_alloc()'.
 740394               //
 740395               return ((zno_t) -1);
 740396             }
 740397           //
 740398           // The zone is allocated: clear the zone and save.
 740399           //
 740400           memset (buffer, 0, SB_MAX_ZONE_SIZE);
 740401           status = zone_write (inode->sb, allocated_zone, buffer);
 740402           if (status < 0)
 740403             {
 740404               //
 740405               // Cannot overwrite the zone. The variable `errno' is
 740406               // set by `zone_write()'.
 740407               //
 740408               return ((zno_t) -1);
 740409             }
 740410           //
 740411           // The zone was allocated and cleared: update the indirect
 740412           // zone table an save it. The inode is not modified, because
 740413           // the indirect table is outside.
 740414           //
 740415           zone_table[i2] = allocated_zone;
 740416           status = zone_write (inode->sb, zone_second, zone_table);
 740417           if (status != 0)
 740418             {
 740419               //
 740420               // Cannot write the zone. The variable `errno' is set
 740421               // by `zone_write()'.
 740422               //
 740423               return ((zno_t) -1);
 740424             }
 740425         }
 740426       //
 740427       // The zone is there: return the zone number.
 740428       //
 740429       return (zone_table[i2]);
 740430     }
 740431 }

 750001 #include <kernel/fs.h>
 750002 #include <errno.h>
 750003 #include <kernel/proc.h>
 750004 //----------------------------------------------------------------------
 750005 int
 750006 path_chdir (pid_t pid, const char *path)
 750007 {
 750008     proc_t   *ps;
 750009     inode_t  *inode_directory;
 750010     int       status;
 750011     char      path_directory[PATH_MAX];
 750012     //
 750013     // Get process.
 750014     //
 750015     ps = proc_reference (pid);
 750016     //
 750017     // The full directory path is needed.
 750018     //
 750019     status = path_full (path, ps->path_cwd, path_directory);
 750020     if (status < 0)
 750021       {
 750022         return (-1);
 750023       }
 750024     //
 750025     // Try to load the new directory inode.
 750026     //
 750027     inode_directory = path_inode (pid, path_directory);
 750028     if (inode_directory == NULL)
 750029       {
 750030         //
 750031         // Cannot access the directory: it does not exists or
 750032         // permissions are not sufficient. Variable `errno' is set by
 750033         // function `inode_directory()'.
 750034         //
 750035         errset (errno);
 750036         return (-1);
 750037       } 
 750038     //
 750039     // Inode loaded: release the old directory and set the new one.
 750040     //
 750041     inode_put (ps->inode_cwd);
 750042     //
 750043     ps->inode_cwd = inode_directory;
 750044     strncpy (ps->path_cwd, path_directory, PATH_MAX);
 750045     //
 750046     // Return.
 750047     //
 750048     return (0);
 750049 }

 760001 #include <kernel/fs.h>
 760002 #include <errno.h>
 760003 #include <kernel/proc.h>
 760004 //----------------------------------------------------------------------
 760005 int
 760006 path_chmod (pid_t pid, const char *path, mode_t mode)
 760007 {
 760008     proc_t   *ps;
 760009     inode_t  *inode;
 760010     //
 760011     // Get process.
 760012     //
 760013     ps = proc_reference (pid);
 760014     //
 760015     // Try to load the file inode.
 760016     //
 760017     inode = path_inode (pid, path);
 760018     if (inode == NULL)
 760019       {
 760020         //
 760021         // Cannot access the file: it does not exists or permissions are
 760022         // not sufficient. Variable `errno' is set by function
 760023         // `inode_directory()'.
 760024         //
 760025         return (-1);
 760026       }
 760027     //
 760028     // Verify to be root or to be the owner.
 760029     //
 760030     if (ps->euid != 0 && ps->euid != inode->uid)
 760031       {
 760032         errset (EACCES);        // Permission denied.
 760033         return (-1);
 760034       }
 760035     //
 760036     // Update the mode: the file type is kept and the
 760037     // rest is taken form the parameter `mode'.
 760038     //
 760039     inode->mode = (S_IFMT & inode->mode) | (~S_IFMT & mode);
 760040     //
 760041     // Save and release the inode.
 760042     //
 760043     inode->changed = 1;
 760044     inode_save (inode);
 760045     inode_put (inode);
 760046     //
 760047     // Return.
 760048     //
 760049     return (0);
 760050 }

 770001 #include <kernel/fs.h>
 770002 #include <errno.h>
 770003 #include <kernel/proc.h>
 770004 //----------------------------------------------------------------------
 770005 int
 770006 path_chown (pid_t pid, const char *path, uid_t uid, gid_t gid)
 770007 {
 770008     proc_t   *ps;
 770009     inode_t  *inode;
 770010     //
 770011     // Get process.
 770012     //
 770013     ps = proc_reference (pid);
 770014     //
 770015     // Must be root, as the ability to change group is not considered.
 770016     //
 770017     if (ps->euid != 0)
 770018       {
 770019         errset (EPERM);                 // Operation not permitted.
 770020         return (-1);
 770021       }
 770022     //
 770023     // Try to load the file inode.
 770024     //
 770025     inode = path_inode (pid, path);
 770026     if (inode == NULL)
 770027       {
 770028         //
 770029         // Cannot access the file: it does not exists or permissions are
 770030         // not sufficient. Variable `errno' is set by function
 770031         // `inode_directory()'.
 770032         //
 770033         return (-1);
 770034       }
 770035     //
 770036     // Update the owner and group.
 770037     //
 770038     if (uid != -1)
 770039       {
 770040         inode->uid     = uid;
 770041         inode->changed = 1;
 770042       }
 770043     if (gid != -1)
 770044       {
 770045         inode->gid     = gid;
 770046         inode->changed = 1;
 770047       }
 770048     //
 770049     // Save and release the inode.
 770050     //
 770051     inode_save (inode);
 770052     inode_put (inode);
 770053     //
 770054     // Return.
 770055     //
 770056     return (0);
 770057 }

 780001 #include <kernel/fs.h>
 780002 #include <errno.h>
 780003 #include <kernel/proc.h>
 780004 //----------------------------------------------------------------------
 780005 dev_t
 780006 path_device (pid_t pid, const char *path)
 780007 {
 780008     proc_t   *ps;
 780009     inode_t  *inode;
 780010     dev_t     device;
 780011     //
 780012     // Get process.
 780013     //
 780014     ps = proc_reference (pid);
 780015     //
 780016     inode = path_inode (pid, path);
 780017     if (inode == NULL)
 780018       {
 780019         errset (errno);
 780020         return ((dev_t) -1);
 780021       }
 780022     //
 780023     if (!(S_ISBLK (inode->mode) || S_ISCHR (inode->mode)))
 780024       {
 780025         errset (ENODEV);                // No such device.
 780026         inode_put (inode);
 780027         return ((dev_t) -1);
 780028       }
 780029     //
 780030     device = inode->direct[0];
 780031     inode_put (inode);
 780032     return (device);
 780033 }

 790001 #include <kernel/fs.h>
 790002 #include <errno.h>
 790003 #include <kernel/proc.h>
 790004 //----------------------------------------------------------------------
 790005 int
 790006 path_fix (char *path)
 790007 {
 790008     char    new_path[PATH_MAX];
 790009     char   *token[PATH_MAX/4];
 790010     int     t;                          // Token index.
 790011     int     token_size;                 // Token array effective size.
 790012     int     comp;                       // String compare return value.
 790013     size_t  path_size;                  // Path string size.
 790014     //
 790015     // Initialize token search.
 790016     //
 790017     token[0] = strtok (path, "/");
 790018     //
 790019     // Scan tokens.
 790020     //
 790021     for (t = 0;
 790022          t < PATH_MAX/4 && token[t] != NULL;
 790023          t++, token[t] = strtok (NULL, "/"))
 790024       {
 790025         //
 790026         // If current token is `.', just ignore it.
 790027         //
 790028         comp = strcmp (token[t], ".");
 790029         if (comp == 0)
 790030           {
 790031             t--;
 790032           }
 790033         //
 790034         // If current token is `..', remove previous token,
 790035         // if there is one.
 790036         //
 790037         comp = strcmp (token[t], "..");
 790038         if (comp == 0)
 790039           {
 790040             if (t > 0)
 790041               {
 790042                 t -= 2;
 790043               }
 790044             else
 790045               {
 790046                 t = -1;
 790047               }
 790048           }
 790049         //
 790050         // `t' will be incremented and another token will be
 790051         // found.
 790052         //
 790053       }
 790054     //
 790055     // Save the token array effective size.
 790056     //
 790057     token_size = t;
 790058     //
 790059     // Initialize the new path string.
 790060     //
 790061     new_path[0] = '\0';
 790062     //
 790063     // Build the new path string.
 790064     //
 790065     if (token_size > 0)
 790066       {
 790067         for (t = 0; t < token_size; t++)
 790068           {
 790069             path_size = strlen (new_path);
 790070             strncat (new_path, "/", 2);
 790071             strncat (new_path, token[t], PATH_MAX - path_size - 1);
 790072           }
 790073       }
 790074     else
 790075       {
 790076         strncat (new_path, "/", 2);
 790077       }
 790078     //
 790079     // Copy the new path into the original string.
 790080     //
 790081     strncpy (path, new_path, PATH_MAX);
 790082     //
 790083     // Return.
 790084     //
 790085     return (0);
 790086 }

 800001 #include <kernel/fs.h>
 800002 #include <errno.h>
 800003 #include <kernel/proc.h>
 800004 //----------------------------------------------------------------------
 800005 int
 800006 path_full (const char *path, const char *path_cwd, char *full_path)
 800007 {
 800008     unsigned int path_size;
 800009     //
 800010     // Check some arguments.
 800011     //
 800012     if (path == NULL || strlen (path) == 0 || full_path == NULL)
 800013       {
 800014         errset (EINVAL);                // Invalid argument.
 800015         return (-1);
 800016       }
 800017     //
 800018     // The main path and the receiving one are right.
 800019     // Now arrange to get a full path name.
 800020     //
 800021     if (path[0] == '/')
 800022       {
 800023         strncpy (full_path, path, PATH_MAX);
 800024         full_path[PATH_MAX-1] = 0;
 800025       }
 800026     else
 800027       {
 800028         if (path_cwd == NULL || strlen (path_cwd) == 0)
 800029           {
 800030             errset (EINVAL);            // Invalid argument.
 800031             return (-1);
 800032           }
 800033         strncpy (full_path, path_cwd, PATH_MAX);
 800034         path_size = strlen (full_path);
 800035         strncat (full_path, "/", (PATH_MAX - path_size));
 800036         path_size = strlen (full_path);
 800037         strncat (full_path, path, (PATH_MAX - path_size));
 800038       }
 800039     //
 800040     // Fix path name so that it has no `..', `.', and no
 800041     // multiple `/'.
 800042     //
 800043     path_fix (full_path);
 800044     //
 800045     // Return.
 800046     //
 800047     return (0);
 800048 }

 810001 #include <kernel/fs.h>
 810002 #include <errno.h>
 810003 #include <kernel/proc.h>
 810004 #include <kernel/k_libc.h>
 810005 //----------------------------------------------------------------------
 810006 #define DIRECTORY_BUFFER_SIZE (SB_MAX_ZONE_SIZE/16)
 810007 //----------------------------------------------------------------------
 810008 inode_t *
 810009 path_inode (pid_t pid, const char *path)
 810010 {
 810011     proc_t     *ps;
 810012     inode_t    *inode;
 810013     dev_t       device;
 810014     char        full_path[PATH_MAX];
 810015     char       *name;
 810016     char       *next;
 810017     directory_t dir[DIRECTORY_BUFFER_SIZE];
 810018     char        dir_name[NAME_MAX+1];
 810019     off_t       offset_dir;
 810020     ssize_t     size_read;
 810021     size_t      dir_size_read;
 810022     ssize_t     size_to_read;
 810023     int         comp;
 810024     int         d;              // Directory index;
 810025     int         status;         // inode_check() return status.
 810026     //
 810027     // Get process.
 810028     //
 810029     ps = proc_reference (pid);
 810030     //
 810031     // Arrange to get a packed full path name.
 810032     //
 810033     path_full (path, ps->path_cwd, full_path);
 810034     //
 810035     // Get the root file system inode.
 810036     //
 810037     inode = inode_get ((dev_t) 0, 1);
 810038     if (inode == NULL)
 810039       {
 810040         errset (errno);
 810041         return (NULL);
 810042       }
 810043     //
 810044     // Save the device number.
 810045     //
 810046     device = inode->sb->device;
 810047     //
 810048     // Variable `inode' already points to the root file system inode:
 810049     // It must be a directory!
 810050     //
 810051     status = inode_check (inode, S_IFDIR, 1, ps->euid);
 810052     if (status != 0)
 810053       {
 810054         //
 810055         // Variable `errno' should be set by inode_check().
 810056         //
 810057         errset (errno);
 810058         inode_put (inode);
 810059         return (NULL);
 810060       }
 810061     //
 810062     // Initialize string scan: find the first path token, after the
 810063     // first `/'.
 810064     //
 810065     name = strtok (full_path, "/");
 810066     //
 810067     // If the original full path is just `/' the variable `name'
 810068     // appears as a null pointer, and the variable `inode' is already
 810069     // what we are looking for.
 810070     //
 810071     if (name == NULL)
 810072       {
 810073         return (inode);
 810074       }
 810075     //
 810076     // There is at least a name after `/' inside the original full
 810077     // path. A scan is going to start: the original value for variable
 810078     // `inode' is a pointer to the root directory inode.
 810079     //
 810080     for (;;)
 810081       {
 810082         //
 810083         // Find next token.
 810084         //
 810085         next = strtok (NULL, "/");
 810086         //
 810087         // Read the directory from the current inode.
 810088         //
 810089         for (offset_dir=0; ; offset_dir += size_read)
 810090           {
 810091             size_to_read = DIRECTORY_BUFFER_SIZE;
 810092             //
 810093             if ((offset_dir + size_to_read) > inode->size)
 810094               {
 810095                 size_to_read = inode->size - offset_dir;
 810096               }
 810097             //
 810098             size_read = inode_file_read (inode, offset_dir, dir,
 810099                                          size_to_read, NULL);
 810100             //
 810101             // The size read must be a multiple of 16.
 810102             //
 810103             size_read = ((size_read / 16) * 16);
 810104             //
 810105             // Check anyway if it is zero.
 810106             //
 810107             if (size_read == 0)
 810108               {
 810109                 //
 810110                 // The directory is ended: release the inode and return.
 810111                 //
 810112                 inode_put (inode);
 810113                 errset (ENOENT);           // No such file or directory.
 810114                 return (NULL);
 810115               }
 810116             //
 810117             // Calculate how many directory items we have read.
 810118             //
 810119             dir_size_read = size_read / 16;
 810120             //
 810121             // Scan the directory to find the current name.
 810122             //
 810123             for (d = 0; d < dir_size_read; d++)
 810124               {
 810125                 //
 810126                 // Ensure to have a null terminated string for
 810127                 // the name found.
 810128                 //
 810129                 memcpy (dir_name, dir[d].name, (size_t) NAME_MAX);
 810130                 dir_name[NAME_MAX] = 0;
 810131                 //
 810132                 comp = strcmp (name, dir_name);
 810133                 if (comp == 0 && dir[d].ino != 0)
 810134                   {
 810135                     //
 810136                     // Found the name and verified that it has a link to
 810137                     // a inode. Now release the directory inode.
 810138                     //
 810139                     inode_put (inode);
 810140                     //
 810141                     // Get next inode and break the loop.
 810142                     //
 810143                     inode = inode_get (device, dir[d].ino);
 810144                     break;
 810145                   }
 810146               }
 810147             //
 810148             // If index `d' is in a valid range, the name was found.
 810149             //
 810150             if (d < dir_size_read)
 810151               {
 810152                 //
 810153                 // The name was found.
 810154                 //
 810155                 break;
 810156               }
 810157           }
 810158         //
 810159         // If the function is still working, a file or a directory
 810160         // was found: see if there is another name after this one
 810161         // to look for. If there isn't, just break the loop.
 810162         //
 810163         if (next == NULL)
 810164           {
 810165             //
 810166             // As no other tokens are to be found, break the loop.
 810167             //
 810168             break;
 810169           }
 810170         //
 810171         // As there is another name after the current one,
 810172         // the current file must be a directory.
 810173         //
 810174         status = inode_check (inode, S_IFDIR, 1, ps->euid);
 810175         if (status != 0)
 810176           {
 810177             //
 810178             // Variable `errno' is set by `inode_check()'.
 810179             //
 810180             errset (errno);
 810181             inode_put (inode);
 810182             return (NULL);
 810183          }
 810184         //
 810185         // The inode is a directory and the user has the necessary
 810186         // permissions: check if it is a mount point and go to the
 810187         // new device root directory if necessary.
 810188         //
 810189         if (inode->sb_attached != NULL)
 810190           {
 810191             //
 810192             // Must find the root directory for the new device, and
 810193             // then go to that inode.
 810194             //
 810195             device = inode->sb_attached->device;
 810196             inode_put (inode);
 810197             inode = inode_get (device, 1);
 810198             status = inode_check (inode, S_IFDIR, 1, ps->euid);
 810199             if (status != 0)
 810200               {
 810201                 inode_put (inode);
 810202                 return (NULL);
 810203               }
 810204           }
 810205         //
 810206         // As a directory was found, and another token follows it,
 810207         // must continue the token scan.
 810208         //
 810209         name = next;
 810210       }
 810211     //
 810212     // Current inode found is the file represented by the requested
 810213     // path.
 810214     //
 810215     return (inode);
 810216 }