TBBT/trace_init/hier.pl

   1 #\r
   2 # Copyright (c) 2002-2003\r
   3 #      The President and Fellows of Harvard College.\r
   4 #\r
   5 # Redistribution and use in source and binary forms, with or without\r
   6 # modification, are permitted provided that the following conditions\r
   7 # are met:\r
   8 # 1. Redistributions of source code must retain the above copyright\r
   9 #    notice, this list of conditions and the following disclaimer.\r
  10 # 2. Redistributions in binary form must reproduce the above copyright\r
  11 #    notice, this list of conditions and the following disclaimer in the\r
  12 #    documentation and/or other materials provided with the distribution.\r
  13 # 3. Neither the name of the University nor the names of its contributors\r
  14 #    may be used to endorse or promote products derived from this software\r
  15 #    without specific prior written permission.\r
  16 #\r
  17 # THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND\r
  18 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  19 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  20 # ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE\r
  21 # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  22 # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
  23 # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
  24 # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
  25 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
  26 # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
  27 # SUCH DAMAGE.\r
  28 #\r
  29 # $Id: hier.pl,v 1.14 2003/07/26 20:52:03 ellard Exp $\r
  30 #\r
  31 # hier.pl - Tools to map out the file system hierarchy.  This is\r
  32 # accomplished by snooping out the lookup calls.\r
  33 #\r
  34 # This is expensive because the hierarchy can require a LOT of space\r
  35 # to store for a large system with lots of files (especially if files\r
  36 # come and go).  Don't construct the hierarchy unless you want it --\r
  37 # and be prepared to prune it from time to time.\r
  38 \r
  39 package hier;\r
  40 \r
  41 # Tables used by the outside world:\r
  42 \r
  43 %fh2Parent              = ();\r
  44 %fh2Name                = ();\r
  45 %fh2Attr                = ();\r
  46 %fh2AttrOrig            = ();\r
  47 %parent2fh              = ();\r
  48 \r
  49 #RFS: init FS\r
  50 %rootsName              = ();\r
  51 %discardFHs = ();\r
  52 %rootsFHs = ();\r
  53 #RFS: dependency table\r
  54 %fhCreate = ();\r
  55 \r
  56 %rfsAllFHs = ();\r
  57 %fhType = (); # we use %fhIsDir instead\r
  58 $rfsLineNum = 0;\r
  59 \r
  60 \r
  61 \r
  62 \r
  63 \r
  64 \r
  65 # Library-private tables and variables.\r
  66 \r
  67 %pendingCallsXIDnow     = ();\r
  68 %pendingCallsXIDfh      = ();\r
  69 %pendingCallsXIDname    = ();\r
  70 \r
  71 $nextPruneTime          = -1;\r
  72 $PRUNE_INTERVAL         = 5 * 60;       # Five minutes.\r
  73 \r
  74 sub processLine {\r
  75         my ($line, $proto, $op, $xid, $client, $now, $response, $fh_type) = @_;\r
  76 \r
  77         &addRfsAllFHs($line, $proto, $op, $uxid,\r
  78                                 $now, $response, $fh_type);\r
  79 \r
  80         if ($now > $nextPruneTime) {\r
  81                 &prunePending ($now - $PRUNE_INTERVAL);\r
  82                 $nextPruneTime = $now + $PRUNE_INTERVAL;\r
  83         }\r
  84 \r
  85         my $uxid = "$client-$xid";\r
  86 \r
  87         # 'lookup', 'create', 'rename', 'delete',\r
  88         # 'getattr', 'setattr'\r
  89 \r
  90         #RFS: add mkdir/rmdir/symlink\r
  91         if ( $op eq 'lookup' || $op eq 'create' || $op eq 'mkdir' || \r
  92              ($op eq 'symlink' && ($proto eq 'C3' || $proto eq 'R3' ) ) ) {\r
  93                 return (&doLookup ($line, $proto, $op, $uxid,\r
  94                                 $now, $response, $fh_type));\r
  95         }\r
  96         elsif ($op eq 'rename') {\r
  97         }\r
  98         elsif ($op eq 'remove' || $op eq 'rmdir') {\r
  99                 # RFS: why remove these entries? Just let them exist since \r
 100                 # there is generation number available to distinguish btw removed dir/file \r
 101                 # and new dir/file with the same inode number.\r
 102                 #return (&doRemove ($line, $proto, $op, $uxid,\r
 103                 #               $now, $response, $fh_type));\r
 104         }\r
 105         elsif ($op eq 'getattr' || $op eq 'read' || $op eq 'write'  ||\r
 106                  ($op eq 'readlink' && ($proto eq 'C3' || $proto eq 'R3' ) ) ) {\r
 107                 return (&doGetAttr ($line, $proto, $op, $uxid,\r
 108                                 $now, $response, $fh_type));\r
 109         }\r
 110         elsif ($op eq 'setattr') {\r
 111         }\r
 112 }\r
 113 \r
 114 \r
 115 # get time stamp\r
 116 \r
 117 sub getTimeStamp{\r
 118         my ($line) = @_;\r
 119 \r
 120         if (! ($line =~ /^[0-9]/)) {\r
 121                 print "getTimeStamp return undef\n";\r
 122                 return undef;\r
 123         }\r
 124         else {\r
 125                 my @l = split (' ', $line, 2);\r
 126                 return $l[0];\r
 127         }\r
 128 }\r
 129 \r
 130 sub addRfsAllFHs {\r
 131         my ($line, $proto, $op, $uxid, $now, $response, $fh_type) = @_;\r
 132 \r
 133         my $fh = undef;\r
 134         \r
 135         my $checkfh = undef;\r
 136         $checkfh = nfsd::nfsDumpParseLineField ($line, 'fh');\r
 137         if (defined $checkfh) {\r
 138                 $fh = nfsd::nfsDumpCompressFH ($fh_type, $checkfh);\r
 139         }\r
 140         \r
 141         my $fh2 = undef;\r
 142 \r
 143         if ($op eq 'rename' || $op eq 'link') {\r
 144                 $checkfh = nfsd::nfsDumpParseLineField ($line, 'fh2');\r
 145                 if (defined $checkfh) {\r
 146                         $fh2 = nfsd::nfsDumpCompressFH ($fh_type, $checkfh);\r
 147                 }       \r
 148         }\r
 149 \r
 150         if (defined $fh) {\r
 151                 # record the first appearance of the fh\r
 152                 if ( !exists  $rfsAllFHs{$fh} )  {\r
 153                         $rfsAllFHs{$fh} = $rfsLineNum ;\r
 154                 }\r
 155         }\r
 156 \r
 157         if (defined $fh2) {\r
 158                 if ( !exists  $rfsAllFHs{$fh2} ) {\r
 159                         $rfsAllFHs{$fh2} = $rfsLineNum;\r
 160                 }\r
 161         }\r
 162 \r
 163         return ;\r
 164 }\r
 165 \r
 166 \r
 167 sub doLookup {\r
 168         my ($line, $proto, $op, $uxid, $now, $response, $fh_type) = @_;\r
 169 \r
 170         if ($proto eq 'C3' || $proto eq 'C2') {\r
 171                 my $tag = ($proto eq 'C3') ? 'name' : 'fn';\r
 172                 my $name = nfsd::nfsDumpParseLineField ($line, $tag);\r
 173 \r
 174                 # All directories have (at least) three names:  the\r
 175                 # given name, and "." and "..".  We're only interested\r
 176                 # in the given name.\r
 177 \r
 178                 if ($name eq '"."' || $name eq '".."') {\r
 179                         return ;\r
 180                 }\r
 181 \r
 182                 my $fh = nfsd::nfsDumpCompressFH ($fh_type,\r
 183                         nfsd::nfsDumpParseLineField ($line, 'fh'));\r
 184 \r
 185                 $pendingCallsXIDnow{$uxid} = $now;\r
 186                 $pendingCallsXIDfh{$uxid} = $fh;\r
 187                 $pendingCallsXIDname{$uxid} = $name;\r
 188         }\r
 189         elsif ($proto eq 'R3' || $proto eq 'R2') {\r
 190                 if (! exists $pendingCallsXIDnow{$uxid}) {\r
 191                         return ;\r
 192                 }\r
 193 \r
 194                 my $pfh = $pendingCallsXIDfh{$uxid};\r
 195                 my $name = $pendingCallsXIDname{$uxid};\r
 196 \r
 197                 delete $pendingCallsXIDnow{$uxid};\r
 198                 delete $pendingCallsXIDfh{$uxid};\r
 199                 delete $pendingCallsXIDname{$uxid};\r
 200 \r
 201                 if ($response eq 'OK') {\r
 202                         my $cfh = nfsd::nfsDumpCompressFH ($fh_type,\r
 203                                         nfsd::nfsDumpParseLineField ($line, 'fh'));\r
 204 \r
 205                         my $type = nfsd::nfsDumpParseLineField ($line, 'ftype');\r
 206 \r
 207                         #if ($type == 2) \r
 208                         {\r
 209                                 $fhIsDir{$cfh} = $type;\r
 210                         }\r
 211 \r
 212                         # Original code\r
 213                         # $fh2Parent{$cfh} = $pfh;\r
 214                         # $fh2Name{$cfh} = $name;\r
 215                         # $parent2fh{"$pfh,$name"} = $cfh;\r
 216                         # RFS code: in case of the rename, we will record the name of the old name\r
 217                         $fh2Parent{$cfh} = $pfh;\r
 218                         if (! exists   $fh2Name{$cfh}) {\r
 219                                 $fh2Name{$cfh} = $name;\r
 220                                 $parent2fh{"$pfh,$name"} = $cfh;\r
 221                         } else {\r
 222                                 # keep the old name in the fh2Name{$cfh}\r
 223                                 # and we also add the newname and pfh mapping\r
 224                                 #$fh2Name{$cfh} = $name;\r
 225                                 $parent2fh{"$pfh,$name"} = $cfh;\r
 226                         }\r
 227 \r
 228                         my ($size, $mode, $atime, $mtime, $ctime, $nlink) =\r
 229                                         nfsd::nfsDumpParseLineFields ($line,\r
 230                                         'size', 'mode',\r
 231                                         'atime', 'mtime', 'ctime', 'nlink');\r
 232                         my $ts = getTimeStamp($line);\r
 233 \r
 234                         # RFS: modify here to get/maintain more file attributes\r
 235                         # we can just check the ctime and compare it with trace-start-time\r
 236                         # to decide whether to create a file/diretory.\r
 237                         # atime - last access time of the file\r
 238                         # mtime - last modification time of the file\r
 239                         # ctime - last file status change time\r
 240                         \r
 241                         #$fh2Attr{$cfh} = "$size $mode $atime $mtime $ctime";\r
 242                         if  (! exists $fh2AttrOrig{$cfh} ) {\r
 243                                 $fh2AttrOrig{$cfh} = "$size $mode $op $atime $mtime $ctime $nlink $ts";\r
 244                         }\r
 245                         $fh2Attr{$cfh} = "$size $mode $op $atime $mtime $ctime $nlink $ts";\r
 246                 }\r
 247 \r
 248         }\r
 249 \r
 250         return ;\r
 251 }\r
 252 \r
 253 sub doRemove {\r
 254         my ($line, $proto, $op, $uxid, $now, $response, $fh_type) = @_;\r
 255 \r
 256         if ($proto eq 'C3' || $proto eq 'C2') {\r
 257                 my $tag = ($proto eq 'C3') ? 'name' : 'fn';\r
 258                 my $name = nfsd::nfsDumpParseLineField ($line, $tag);\r
 259 \r
 260                 # All directories have (at least) three names:  the\r
 261                 # given name, and "." and "..".  We're only interested\r
 262                 # in the given name.\r
 263 \r
 264                 if ($name eq '"."' || $name eq '".."') {\r
 265                         return ;\r
 266                 }\r
 267 \r
 268                 my $pfh = nfsd::nfsDumpCompressFH ($fh_type,\r
 269                         nfsd::nfsDumpParseLineField ($line, 'fh'));\r
 270 \r
 271                 if (! exists $parent2fh{"$pfh,$name"}) {\r
 272                         return ;\r
 273                 }\r
 274 \r
 275                 $pendingCallsXIDnow{$uxid} = $now;\r
 276                 $pendingCallsXIDfh{$uxid} = $pfh;\r
 277                 $pendingCallsXIDname{$uxid} = $name;\r
 278         }\r
 279         elsif ($proto eq 'R3' || $proto eq 'R2') {\r
 280                 if (! exists $pendingCallsXIDnow{$uxid}) {\r
 281                         return ;\r
 282                 }\r
 283 \r
 284                 my $pfh = $pendingCallsXIDfh{$uxid};\r
 285                 my $name = $pendingCallsXIDname{$uxid};\r
 286 \r
 287                 delete $pendingCallsXIDfh{$uxid};\r
 288                 delete $pendingCallsXIDname{$uxid};\r
 289                 delete $pendingCallsXIDnow{$uxid};\r
 290 \r
 291                 if (! exists $parent2fh{"$pfh,$name"}) {\r
 292                         return ;\r
 293                 }\r
 294 \r
 295                 my $cfh = $parent2fh{"$pfh,$name"};\r
 296 \r
 297                 if ($response eq 'OK') {\r
 298                         if ($op eq 'remove') {\r
 299                                 printFileInfo ($cfh, 'D');\r
 300 \r
 301                                 delete $fh2Parent{$cfh};\r
 302                                 delete $fh2Name{$cfh};\r
 303                                 delete $fh2Attr{$cfh};\r
 304                                 delete $fhs2AttrOrig{$cfg};\r
 305                                 delete $parent2fh{"$pfh,$name"};\r
 306                         }\r
 307                 }\r
 308         }\r
 309 \r
 310         return ;\r
 311 }\r
 312 \r
 313 sub doGetAttr {\r
 314         my ($line, $proto, $op, $uxid, $now, $response, $fh_type) = @_;\r
 315 \r
 316         if ($proto eq 'C3' || $proto eq 'C2') {\r
 317                 my $fh = nfsd::nfsDumpCompressFH ($fh_type,\r
 318                         nfsd::nfsDumpParseLineField ($line, 'fh'));\r
 319 \r
 320                 #if (nfsd::nfsDumpParseLineField ($line, 'fh')\r
 321                 #               eq '00018961-57570100-d2440000-61890100') {\r
 322                 #       printf STDERR "Seen it ($op)\n";\r
 323                 #}\r
 324 \r
 325                 if (! defined $fh) {\r
 326                         return ;\r
 327                 }\r
 328 \r
 329                 $pendingCallsXIDnow{$uxid} = $now;\r
 330                 $pendingCallsXIDfh{$uxid} = $fh;\r
 331 # RFS debug code\r
 332 #my $wantfh = "6189010057570100200000000000862077ed3800d24400006189010057570100";\r
 333 #if ($fh eq $wantfh) {\r
 334 #       print "JIAWU: doGetAttr call $wantfh\n";\r
 335 #}\r
 336         }\r
 337         else {\r
 338                 if (! exists $pendingCallsXIDnow{$uxid}) {\r
 339                         return ;\r
 340                 }\r
 341 \r
 342                 my $fh = $pendingCallsXIDfh{$uxid};\r
 343                 delete $pendingCallsXIDfh{$uxid};\r
 344                 delete $pendingCallsXIDnow{$uxid};\r
 345 # RFS debug code\r
 346 #my $wantfh = "6189010057570100200000000000862077ed3800d24400006189010057570100";\r
 347 #if ($fh eq $wantfh) {\r
 348 #       print "JIAWU: doGetAttr response $wantfh\n";\r
 349 #}\r
 350 \r
 351                 if ($response ne 'OK') {\r
 352                         return ;\r
 353                 }\r
 354 \r
 355                 my ($ftype) = nfsd::nfsDumpParseLineFields ($line, 'ftype');\r
 356                 if (!defined $ftype) {\r
 357                         print STDERR "BAD $line";\r
 358                         return ;\r
 359                 }\r
 360 \r
 361                 #if ($ftype == 2) \r
 362                 {\r
 363                         $fhIsDir{$fh} = $ftype;\r
 364                 }\r
 365 \r
 366                 #RFS comment: here if fh is a directory, then it will not be add \r
 367                 # in the two hash table %fh2Attr(%fh2AttrOrig) and %fh2Name\r
 368                 # if ($ftype != 1) {\r
 369                 #       return ;\r
 370                 #}\r
 371                 if ($ftype != 1) {\r
 372                         #return ;\r
 373                 }\r
 374 \r
 375 \r
 376                 my ($mode, $size, $atime, $mtime, $ctime, $nlink) =\r
 377                                 nfsd::nfsDumpParseLineFields ($line,\r
 378                                 'mode', 'size', 'atime', 'mtime', 'ctime', 'nlink');\r
 379                 my $ts = getTimeStamp($line);\r
 380 \r
 381                         # RFS: modify here to get/maintain more file attributes\r
 382                         # we can just check the ctime and compare it with trace-start-time\r
 383                         # to decide whether to create a file/diretory.\r
 384                         # atime - last access time of the file\r
 385                         # mtime - last modification time of the file\r
 386                         # ctime - last file status change time\r
 387 \r
 388                         # $fh2Attr{$fh} = "$size $mode $atime $mtime $ctime";\r
 389 \r
 390                         if  (! exists $fh2AttrOrig{$fh} ) {\r
 391                                 $fh2AttrOrig{$fh} = "$size $mode $op $atime $mtime $ctime $nlink $ts";\r
 392                         }\r
 393                         $fh2Attr{$fh} = "$size $mode $op $atime $mtime $ctime $nlink $ts";\r
 394         }\r
 395 }\r
 396 \r
 397 # Purge all the pending XID records dated earlier than $when (which is\r
 398 # typically at least $PRUNE_INTERVAL seconds ago).  This is important\r
 399 # because otherwise missing XID records can pile up, eating a lot of\r
 400 # memory. \r
 401   \r
 402 sub prunePending {\r
 403         my ($when) = @_;\r
 404 \r
 405         foreach my $uxid ( keys %pendingCallsXIDnow ) {\r
 406                 if ($pendingCallsXIDnow{$uxid} < $when) {\r
 407 # RFS debug code\r
 408 my $fh = $pendingCallsXIDfh{$uxid};\r
 409 my $wantfh = "6189010057570100200000000000862077ed3800d24400006189010057570100";\r
 410 if ($fh eq $wantfh) {\r
 411         print "JIAWU: prunePending $wantfh\n";\r
 412 }\r
 413 #enf RFS\r
 414                         delete $pendingCallsXIDnow{$uxid};\r
 415                 }\r
 416         }\r
 417 \r
 418         return ;\r
 419 }\r
 420 \r
 421 # Return as much of the path for the given fh as possible.  It may or\r
 422 # may not reach the root (or the mount point of the file system), but\r
 423 # right now we don't check.  Usually on busy systems the data is\r
 424 # complete enough so that most paths are complete back to the mount\r
 425 # point.\r
 426 \r
 427 sub findPath {\r
 428         my ($fh) = @_;\r
 429         my $isdir = 0;\r
 430         my $cnt = 0;\r
 431         my $MaxPathLen = 40;\r
 432 \r
 433         if (exists $fhIsDir{$fh} && $fhIsDir{$fh}==2) {\r
 434                 $isdir = 1;\r
 435         }\r
 436 \r
 437         my @path = ();\r
 438         while ($fh && exists $fh2Name{$fh}) {\r
 439                 unshift (@path, $fh2Name{$fh});\r
 440 \r
 441                 if ( ($fh2Name{$fh} ne '"RFSNN0"' ) ) {\r
 442                         if (! exists $fh2Parent{$fh}) {\r
 443                                 print STDERR "$fh2Name{$fh} ";\r
 444                                 if ( ($fh2Name{$fh} eq '"RFSNN0"' ) ) {\r
 445                                         print STDERR "eq RFSNN0\n";\r
 446                                 } else {\r
 447                                         print STDERR "NOT eq RFSNN0\n";\r
 448                                 }\r
 449                         }\r
 450                         if ($fh eq $fh2Parent{$fh}) {\r
 451                                 unshift (@path, '(LOOP)');\r
 452                                 last;\r
 453                         }\r
 454                 }\r
 455 \r
 456                 if ($cnt++ > $MaxPathLen) {\r
 457                         print STDERR "findPath: path too long (> $MaxPathLen)\n";\r
 458                         unshift (@path, '(TOO-LONG)');\r
 459                         last;\r
 460                 }\r
 461 \r
 462                 $fh = $fh2Parent{$fh};\r
 463         }\r
 464 \r
 465         # RFS: append the ~user (fh and !exists $fh2Name{$fh} and type is Directory)\r
 466         if ($fh && !exists $fh2Name{$fh} && (exists $fhIsDir{$fh} && $fhIsDir{$fh}==2) ) {\r
 467                 if (exists $rootsName{$fh}) {\r
 468                         #print "JIAWU: $rootsName{$fh}\n";\r
 469                         unshift(@path, $rootsName{$fh});\r
 470                 } else {\r
 471                         print "JIAWU: WARNING! No rootsName for this fh: $fh\n";\r
 472                         unshift(@path, $fh);\r
 473                 }\r
 474         } else {\r
 475                 if ($fh && !exists $fh2Name{$fh} && (!exists $fhIsDir{$fh} || (exists $fhIsDir{$fh} && $fhIsDir{$fh}!=2)) ) {\r
 476                         if (exists $discardFHs{$fh}) {\r
 477                                 open NOATTRDIR, ">>noattrdirdiscard" || die "open noattrdirdiscard failed\n";\r
 478                                 print NOATTRDIR "$fh DISCARD\n";\r
 479                                 close NOATTRDIR;\r
 480                         } else {\r
 481                                 # RFS: if a possible fh without attr and name, then regard it as a special root ~/RFSNN0\r
 482                                 unshift(@path, '"RFSNN0"');\r
 483                                 $fhIsDir{$fh}=2;\r
 484                                 $fh2Name{$fh} = '"RFSNN0"';\r
 485                                 $rootsName{$fh} = '"RFSNN0"';\r
 486                                 open NOATTRDIR, ">>noattrdir-root";\r
 487                                 print NOATTRDIR "$fh /RFSNN0/\n";\r
 488                                 close NOATTRDIR;\r
 489                         }\r
 490                 }\r
 491         }\r
 492 \r
 493         \r
 494         my $str = '';\r
 495         $cnt = 0;\r
 496         foreach my $p ( @path ) {\r
 497                 $p =~ s/^.//;\r
 498                 $p =~ s/.$//;\r
 499                 $str .= "/$p";\r
 500                 $cnt++;\r
 501         }\r
 502 \r
 503         if ($isdir) {\r
 504                 $str .= '/';\r
 505         }\r
 506 \r
 507         if ($cnt == 0) {\r
 508                 $str = '.';\r
 509         }\r
 510 \r
 511         return ($str, $cnt);\r
 512 }\r
 513 \r
 514 \r
 515 $total_unknown_fh = 0;\r
 516 $total_known_fh = 0;\r
 517 \r
 518 sub printAll {\r
 519         my ($start_time, $out) = @_;\r
 520 \r
 521         my %allfh = ();\r
 522         my $fh;\r
 523         my $u = 0;\r
 524         my $k = 0;\r
 525 \r
 526         # RFS print more information here\r
 527         open (OUT_RFS, ">rfsinfo") ||\r
 528                 die "Can't create $OutFileBaseName.rfs.";\r
 529                 \r
 530         foreach $fh ( keys %fh2Attr ) {\r
 531                 $allfh{$fh} = 1; \r
 532         }\r
 533         foreach $fh ( keys %fh2Name ) {\r
 534                 $allfh{$fh} = 1; \r
 535         }\r
 536 \r
 537         #RFS: before printFileInfo, name those roots' name\r
 538 \r
 539         #RFS there are three kind of fh\r
 540         # 1. fh/name paired (fh/attr must)\r
 541         # 2. fh/attr but no fh/name: type file (discard related operations)\r
 542         # 3. fh/attr but no fh/name: type dir (keep as persuedo root)\r
 543         $u = $k = 0;\r
 544         my $sn=1;\r
 545         foreach $fh ( keys %allfh ) {\r
 546                 if (exists $fh2Parent{$fh} ) {\r
 547                         $k++;\r
 548                 }\r
 549                 else {\r
 550                         $u++;\r
 551                         my $type = (exists $fhIsDir{$fh} && $fhIsDir{$fh}==2) ? 'D' : 'F';\r
 552                         if ($type eq 'D') {\r
 553                                 $rootsName{$fh} = sprintf("\"RFSNN%d\"", $sn++);\r
 554                                 $rootsFHs{$fh} = 2;\r
 555                         }\r
 556                         else {\r
 557                                 $discardFHs{$fh} = 1;\r
 558                         }\r
 559                 }\r
 560         }\r
 561         print OUT_RFS "#stat: fh with parent = $k, fh without parent = $u\n";\r
 562         $u = keys %rootsFHs;\r
 563         print OUT_RFS "#RFS: root fh list($u)\n";\r
 564         foreach $fh (keys %rootsName) {\r
 565                 print OUT_RFS "#RFS: $rootsName{$fh} $fh\n";\r
 566         }\r
 567         $u = keys %discardFHs;\r
 568         print OUT_RFS "#RFS: discard fh list($u)\n";\r
 569         print OUT_RFS join("\n", keys %discardFHs, "");\r
 570         \r
 571 \r
 572         print $out "#F type state fh path pathcount attrOrig(size,mode,op,atime,mt,ct) attrLast(size,mode,op,at,mt,ct)\n";\r
 573 \r
 574         print $out "#T starttime = $start_time\n";\r
 575         foreach $fh ( keys %allfh ) {\r
 576                 printFileInfoOutputFile ($fh, 'A', $out);\r
 577         }\r
 578         \r
 579         my $numfh2Name = keys %fh2Name;\r
 580         my $numfh2Attr = keys %fh2Attr;\r
 581         print OUT_RFS "fh2name has $numfh2Name, fh2Attr has $numfh2Attr\n";\r
 582 \r
 583         \r
 584         $u = $k = 0;\r
 585         foreach $fh ( keys %allfh ) {\r
 586                 if ( exists $fh2Name{$fh} ) {$k++;}\r
 587                 else {$u++;}\r
 588         }\r
 589         print OUT_RFS "#stat: total fh with name = $k, without name = $u\n";\r
 590 \r
 591         print OUT_RFS "#stat: finally, total known fh = $total_known_fh, unknown = $total_unknown_fh\n";\r
 592 \r
 593 # Note: fh with name (8303), fh without name (103)\r
 594 #          root fh list: 18\r
 595 #          discard fh list: 85\r
 596 #          known fh (8321): ( fh with name(8303) + root fh list (18) = 8321)\r
 597 #          unknown fh (85)\r
 598 #\r
 599 # All fh from the those data structures: 8321 + 85 = 8303+103\r
 600 # Or, in keys %allfh\r
 601 #\r
 602 # \r
 603         print OUT_RFS "#RFS\n";\r
 604         close OUT_RFS;  \r
 605 \r
 606         open (MISSED, ">missdiscardfh") ||\r
 607                         die "Can't create missdiscardfh.";\r
 608         foreach $fh (keys %rfsAllFHs) {\r
 609                 if ( !exists $allfh{$fh} && \r
 610                      ( (defined $fh2Name{$fh}) && ($fh2Name{$fh} ne '"RFSNN0"')) ) {\r
 611                         print MISSED "$fh LN: $rfsAllFHs{$fh}\n"\r
 612                 }\r
 613         }\r
 614         close MISSED;\r
 615 \r
 616 # check for a special fh\r
 617 #my $wantfh = "6189010057570100200000000000862077ed3800d24400006189010057570100";\r
 618 #if ($allfh{$wantfh} == 1) {\r
 619 #       print OUT_RFS "JIAWU: found $wantfh\n";\r
 620 #} else {\r
 621 #       print OUT_RFS "JIAWU: NOT found $wantfh\n";\r
 622 #}\r
 623 #foreach $fh ( keys %allfh ) {\r
 624 #       if ( $fh eq $wantfh ) {\r
 625 #               print OUT_RFS "JIAWU: found $wantfh\n";\r
 626 #               printFileInfoOutputFile ($fh, 'JIAWU', *OUT_RFS);\r
 627 #               last;\r
 628 #       }\r
 629 #}\r
 630 #print OUT_RFS "JIAWU: after \n";\r
 631 \r
 632 \r
 633 }\r
 634 \r
 635 sub printFileInfoOutputFile {\r
 636         my ($fh, $state, $out) = @_;\r
 637 \r
 638         my ($p, $c) = findPath ($fh);\r
 639         \r
 640         if ($c == 0) {$total_unknown_fh++;}\r
 641         else {$total_known_fh++;}\r
 642         \r
 643         #my $type = (exists $fhIsDir{$fh} && $fhIsDir{$fh}==2) ? 'D' : 'F';\r
 644         my $type = $fhIsDir{$fh};\r
 645         if (!defined $type) \r
 646         {\r
 647                 print STDERR "unknown ftype(U) for fh: $fh\n"; \r
 648                 $type = 'U';\r
 649         }\r
 650         my $attr = (exists $fh2Attr{$fh}) ?\r
 651                         $fh2Attr{$fh} : "-1 -1 -1 -1 -1 -1 -1 -1";\r
 652         my $attrOrig = (exists $fh2AttrOrig{$fh}) ?\r
 653                         $fh2AttrOrig{$fh} : "-1 -1 -1 -1 -1 -1 -1 -1";\r
 654 \r
 655         print $out "F $type $state $fh $p $c $attrOrig $attr\n";\r
 656 }\r
 657 \r
 658 sub printFileInfo {\r
 659         my ($fh, $state) = @_;\r
 660 \r
 661         my ($p, $c) = findPath ($fh);\r
 662         \r
 663         if ($c == 0) {$total_unknown_fh++;}\r
 664         else {$total_known_fh++;}\r
 665         \r
 666         my $type = (exists $fhIsDir{$fh} && $fhIsDir{$fh}==2) ? 'D' : 'F';\r
 667         my $attr = (exists $fh2Attr{$fh}) ?\r
 668                         $fh2Attr{$fh} : "-1 -1 -1 -1 -1 -1 -1 -1";\r
 669         my $attrOrig = (exists $fh2AttrOrig{$fh}) ?\r
 670                         $fh2AttrOrig{$fh} : "-1 -1 -1 -1 -1 -1 -1 -1";\r
 671 \r
 672         print "F $type $state $fh $p $c $attrOrig $attr\n";\r
 673 }\r
 674 \r
 675 #\r
 676 # The flow to create the dependency table\r
 677 # \r
 678 # create(dirfh, name, attr) -->newfh, new attr\r
 679 # mkdir(dirfh, name, attr) -> newfh, new attr\r
 680 #\r
 681 # remove(dirfh, name) --> status\r
 682 # rmdir(dirfh, name) --> status\r
 683 # rename(dirfh, name, todirfh, toname) --> status\r
 684 #\r
 685 # link(newdirfh, newname, dirfh, name) --> status (newdir/newname=>dir/name)\r
 686 # syslink(newdirfh, newname, string) --> status (newdir/newname=>"string")\r
 687 # readlink(fh) --> string\r
 688 # lookup(dirfh, name) --> fh, attr\r
 689 # getattr(fh) --> attr\r
 690 # setattr(fh, attr) --> attr\r
 691 # read(fh, offset, count) -> attr, data\r
 692 # write(fh, offset, count, data) --> attr\r
 693 # readdir(dirfh, cookie, count) --> entries\r
 694 # statfs(fh) --> status\r
 695 #\r
 696 #\r
 697 #\r
 698 #\r
 699 # for each line the trace file: \r
 700 #       if (op == R2 or R3) continue; #skip the response line\r
 701 #       switch (the op)\r
 702 #       {\r
 703 #       # CREATION OPs:\r
 704 #       case create:\r
 705 #       case remove:\r
 706 #       # DELETE OPs:\r
 707 #       case mkdir:\r
 708 #       case rmdir:\r
 709 #       # other OPs\r
 710 #\r
 711 #\r
 712 #\r
 713 #\r
 714 #\r
 715 1;\r