home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / uccs / root.14 / etc / conf / bin / idoptimize next >
Text File  |  1998-08-19  |  6KB  |  396 lines
  1. #!/usr/bin/ksh
  2. #ident    "@(#)ktool:common/ktool/idtools/idoptimize    1.4"
  3. function cleanup
  4. {
  5.     case "$1" in
  6.     clobber)
  7.         rm -rf $OPTDIR/*
  8.         ;;
  9.     '')
  10.         rm -f $OPTDIR/*.r
  11.         rm -f $OPTDIR/*.keep
  12.         rm -f $OPTDIR/*.blocks
  13.         rm -f $OPTDIR/log.*.o
  14.         ;;
  15.     *)
  16.         usage
  17.     esac
  18. }
  19.  
  20. function add_interface
  21. {
  22.     set $xopt
  23.     INTFILE=$ROOT/etc/conf/interface.d/ddi.5-strict
  24.     grep '^calllog$' $INTFILE > /dev/null 2>&1 ||
  25.         ed - $INTFILE > /dev/null 2>&1 <<-\!
  26.             $
  27.             a
  28.             # added by idoptimize
  29.             calllog
  30.             .
  31.             w
  32.             q
  33.         !
  34. }
  35.  
  36. function rm_interface
  37. {
  38.     INTFILE=$ROOT/etc/conf/interface.d/ddi.5-strict
  39.     while grep 'added by idoptimize$' $INTFILE > /dev/null 2>&1
  40.     do
  41.         ed - $INTFILE > /dev/null 2>&1 <<-\!
  42.             /added by idoptimize/
  43.             d
  44.             d
  45.             w
  46.             q
  47.         !
  48.     done
  49. }
  50.  
  51. function setup_logging
  52. {
  53.     set $xopt
  54.     if [ -n "$fopt" ]
  55.     then
  56.         setup_function_logging "$@"
  57.         return $?
  58.     fi
  59.     rm -f $OPTDIR/call.log
  60.     if [ -n "$1" ]
  61.     then
  62.         for i
  63.         do
  64.             echo $i
  65.         done > $OPTDIR/block.log
  66.     else
  67.         echo all > $OPTDIR/block.log
  68.     fi
  69.     setup_rebuild
  70. }
  71.  
  72. function setup_function_logging
  73. {
  74.     rm -f $OPTDIR/block.log
  75.     add_interface
  76.     if [ -n "$1" ]
  77.     then
  78.         for i
  79.         do
  80.             echo $i
  81.         done > $OPTDIR/call.log
  82.     else
  83.         echo all > $OPTDIR/call.log
  84.     fi
  85.     ( cd /usr/ccs/lib/fur; cc -DKERNEL -O -DNUMCALLS=$NUMCALLS -c calllog.c )
  86.     setup_rebuild
  87. }
  88.  
  89. function setup_rebuild
  90. {
  91.     if [ -n "$ROOT" -a "$ROOT" != / ]
  92.     then
  93.         touch $ROOT/etc/conf/.rebuild
  94.     else
  95.         idbuild > /dev/null 2>&1
  96.     fi
  97. }
  98.  
  99. function turnoff_logging
  100. {
  101.     set $xopt
  102.     rm_interface
  103.     setup_rebuild
  104.     rm -f $OPTDIR/block.log $OPTDIR/call.log
  105. }
  106.  
  107. function staticize
  108. {
  109.     set $xopt
  110.     if [ -z "$1" ]
  111.     then
  112.         set -- `modadmin -s | sed 's!^.*/!!'`
  113.     fi
  114.     for i
  115.     do
  116.         if grep '$static' $ROOT/etc/conf/sdevice.d/$i > /dev/null
  117.         then
  118.             echo $i already static
  119.             continue
  120.         fi
  121.         ed - $ROOT/etc/conf/sdevice.d/$i > /dev/null 2>&1 <<-\!
  122.             /version [0-9]/
  123.             a
  124.             # added by idoptimize
  125.             $static
  126.             .
  127.             w
  128.             q
  129.         !
  130.     done
  131. }
  132.  
  133. function unstaticize
  134. {
  135.     set $xopt
  136.     (
  137.         cd $ROOT/etc/conf/sdevice.d
  138.         if [ -z "$1" ]
  139.         then
  140.             set -- `grep -l 'added by idoptimize' *`
  141.         fi
  142.         for i
  143.         do
  144.             ed - $i > /dev/null 2>&1 <<-\!
  145.                 /added by idoptimize/
  146.                 d
  147.                 d
  148.                 w
  149.                 q
  150.             !
  151.         done
  152.     )
  153. }
  154.  
  155. function read_modlist
  156. {
  157.     #set -- $(modadmin -s)
  158.     drvs="`modadmin -s | sed -n 's!^.*/!!p'` unix"
  159.     return
  160. }
  161.  
  162. function error
  163. {
  164.     echo "Error Processing Driver: $i" >&2
  165.     exit 1
  166. }
  167.  
  168. function clearcalls
  169. {
  170.     idreadlog -w CallCount CallSize > /dev/null 2>&1
  171. }
  172.  
  173. function clearblocks
  174. {
  175.     typeset i j
  176.     set $xopt
  177.     whence idreadlog > /dev/null 2>&1 || { print -u2 idreadlog not found; exit 1; }
  178.     if [ ! -d $OPTDIR ]
  179.     then
  180.         mkdir $OPTDIR
  181.     fi
  182.     cd $OPTDIR
  183.     if [ -z "$1" ]
  184.     then
  185.         read_modlist
  186.         set -- $drvs
  187.     fi
  188.     let j=0
  189.     for i
  190.     do
  191.         #set -x
  192.         #eval size=\$sizes$i
  193.         #[ -n "$size" ] || error $i
  194.         addr=${i}BlockCount
  195.         size=${i}BlockSize
  196.         idreadlog -w $addr $size > /dev/null 2>&1 && let j=j+1
  197.         set +x
  198.     done
  199.     if clearcalls || (( $j ))
  200.     then
  201.         return 0
  202.     else
  203.         print -u2 No logging information in kernel
  204.         return 1
  205.     fi
  206. }
  207.  
  208. function getcalls
  209. {
  210.     idreadlog -r CallCount CallSize 2>/dev/null | readlog > $OPTDIR/call.count 2>/dev/null
  211. }
  212.  
  213. function getblocks
  214. {
  215.     set $xopt
  216.     typeset i j
  217.     whence idreadlog > /dev/null 2>&1 || { print -u2 idreadlog not found; exit 1; }
  218.     if [ ! -d $OPTDIR ]
  219.     then
  220.         mkdir $OPTDIR
  221.     fi
  222.     cd $OPTDIR
  223.     if [ -z "$1" ]
  224.     then
  225.         read_modlist
  226.         set -- $drvs
  227.     fi
  228.     let j=0
  229.     for i
  230.     do
  231.         #eval size=\$sizes$i
  232.         #[ -n "$size" ] || error $i
  233.         addr=${i}BlockCount
  234.         size=${i}BlockSize
  235.         if [ "$i" = unix ]
  236.         then
  237.             DRIVER=unix.r
  238.         else
  239.             DRIVER=$i.r
  240.         fi
  241.         if [ -n "$mopt" ] && [ -f $i.blocks ]
  242.         then
  243.             if idreadlog -r $addr $size > $i.blocks.tmp 2>/dev/null
  244.             then
  245.                 let j=j+1
  246.             else
  247.                 rm $i.blocks.tmp
  248.                 continue
  249.             fi
  250.             [ ! -s $i.blocks.tmp ] || fur -M $i.blocks -K $i.keep -o $i.order -r -f "$i.blocks $i.blocks.tmp" $DRIVER || error $i
  251.             rm -f $i.blocks.tmp
  252.         else
  253.             if idreadlog -r $addr $size > $i.blocks 2>/dev/null
  254.             then
  255.                 let j=j+1
  256.             else
  257.                 rm $i.blocks
  258.                 continue
  259.             fi
  260.             [ ! -s $i.blocks ] || fur -K $i.keep -o $i.order -r -f $i.blocks $DRIVER
  261.         fi
  262.         if [ ! -s $i.blocks -o ! -s $i.order ]
  263.         then
  264.             rm -f $i.blocks $i.order
  265.             continue
  266.         fi
  267.     done
  268.     if getcalls || (( $j ))
  269.     then
  270.         setup_rebuild
  271.         return 0
  272.     else
  273.         print -u2 No logging information in kernel
  274.         return 1
  275.     fi
  276. }
  277.  
  278. function usage
  279. {
  280.     echo "Illegal option" >&2
  281.     echo "Usage:" >&2
  282.     echo "\tidoptimize -C [clobber] - clean up files - clobber removes\n\t\t\tuseful information but saves more space" >&2
  283.     echo "\tidoptimize -c [module]... - clear log files in running kernel" >&2
  284.     echo "\tidoptimize -f [module]... - next rebuild will set up function logging for modules" >&2
  285.     echo "\tidoptimize -g [-m] [module]... - get log files from running kernel\n\t\t\t\t-m merges into last log file" >&2
  286.     echo "\tidoptimize -L [module]... - next rebuild will turn off logging for modules" >&2
  287.     echo "\tidoptimize -l [module]... - next rebuild will set up logging for modules" >&2
  288.     echo "\tidoptimize -s [module]... - make all modules currently loaded, static" >&2
  289.     echo "\tidoptimize -u - undoes 'idoptimize -s'" >&2
  290.     exit 1
  291. }
  292.  
  293. if [ "${ROOT:=/}" != "/" ]
  294. then
  295.     ROOT=${ROOT}${MACH:+"/$MACH"}
  296. fi
  297. OPTDIR=$ROOT/etc/conf/optimize.d
  298. if [ ! -d "$OPTDIR" ]
  299. then
  300.     mkdir $OPTDIR
  301.     chmod 755 $OPTDIR
  302. fi
  303. clobber=
  304. [ -n "$NUMCALLS" ] || NUMCALLS=65536
  305. Copt=
  306. copt=
  307. fopt=
  308. gopt=
  309. Lopt=
  310. lopt=
  311. mopt=
  312. sopt=
  313. uopt=
  314. xopt=+x
  315. while getopts :CcfgLlmsux opt
  316. do
  317.     case "$opt" in
  318.     C)
  319.         Copt=on
  320.         ;;
  321.     c)
  322.         copt=on
  323.         ;;
  324.     f)
  325.         fopt=on
  326.         ;;
  327.     g)
  328.         gopt=on
  329.         ;;
  330.     L)
  331.         Lopt=on
  332.         ;;
  333.     l)
  334.         lopt=on
  335.         ;;
  336.     m)
  337.         mopt=on
  338.         ;;
  339.     s)
  340.         sopt=on
  341.         ;;
  342.     u)
  343.         uopt=on
  344.         ;;
  345.     x)
  346.         xopt=-x
  347.         ;;
  348.     *)
  349.         usage
  350.     esac
  351. done
  352. PATH=/sbin:$ROOT/etc/conf/bin:$PATH:/etc/conf/bin
  353. shiftval=`expr $OPTIND - 1`
  354. shift $shiftval
  355. set $xopt
  356. if [ -n "$mopt" -a -z "$gopt" ]
  357. then
  358.     usage
  359. fi
  360. if [ -n "$fopt" -a -z "$lopt" -a -z "$Lopt" ]
  361. then
  362.     usage
  363. fi
  364. if [ "$Copt$copt$gopt$Lopt$lopt$sopt$uopt" != on ]
  365. then
  366.     usage
  367. fi
  368. if [ -n "$Copt" ]
  369. then
  370.     cleanup "$@"
  371. fi
  372. if [ -n "$copt" ]
  373. then
  374.     clearblocks "$@"
  375. fi
  376. if [ -n "$gopt" ]
  377. then
  378.     getblocks "$@"
  379. fi
  380. if [ -n "$Lopt" ]
  381. then
  382.     turnoff_logging "$@"
  383. fi
  384. if [ -n "$lopt" ]
  385. then
  386.     setup_logging "$@"
  387. fi
  388. if [ -n "$sopt" ]
  389. then
  390.     staticize "$@"
  391. fi
  392. if [ -n "$uopt" ]
  393. then
  394.     unstaticize "$@"
  395. fi
  396.