Bazz's Code Developments

Okies,

so if you haven’t heard, I am hacking the Sun Blade 150, it’s a machine at school they still run that’s 10 years old. Pathetic. But it’s a good challenge for me to conquer and learn about operating systems at the same time.

So, I was very easily confused and have finally sorted out many things. First of all, the computer in question had several references that it was a Sun Blade 100… You can see why I am off to a bad start..

I eventually determined that I would need my own replica of the machine (not virtualized, cause it looks like a Booty Face). So I went ahead thinking it was a Sun Blade 100 and started getting confused. Good thing I did my homework:

Queried the target machines processing speed:

bazz@blade72[pts/1][~] psrinfo -v
Status of processor 0 as of: 10/06/14 04:11:03
  Processor has been on-line since 03/16/13 13:50:49.
  The sparcv9 processor operates at 550 MHz,
        and has a sparcv9 floating point processor.
bazz@blade72[pts/1][~]

That lil’ command gave us some good info, but not everything. SPARCv9, 550MHz. OK.. what about cpu-arch? This next command gives us everything we want:

bazz@blade72[pts/1][~] kstat | grep -A 20 --text cpu_info
module: cpu_info                        instance: 0
name:   cpu_info0                       class:    misc
        chip_id                         0
        clock_MHz                       550
        cpu_type                        sparcv9
        crtime                          49.678984543
        device_ID                       0
        fpu_type                        sparcv9
        implementation                  UltraSPARC-IIe
        snaptime                        49127245.7381345
        state                           on-line
        state_begin                     1363456249

I also like to do

kstat | grep -a implementation

grep’s -a is the same as –text, as was used because grep complained the output was binary from kstat..

Here is where I got confused:

bazz@blade72[pts/1][~] uname -a
SunOS blade72 5.8 Generic_117350-51 sun4u sparc SUNW,Sun-Blade-100 Solaris

What’s that, Sun-Blade-100?? WTF? AH!! So the system Sun Blade 150 is based on the platform SUNW,Sun-Blade-100.. OK! This is confirmed by the fact that Blade 100’s cannot clock at 550MHz stock.

Another hint was given with the df -h command. Apparently Blade 100 cannot have > 20 GB hard drives, but target had a ~30GB HDD..

It’s not Over – Narrowing Down CPU Architecture

SPARCv9, ultraSPARC-IIe, cool. Looking through the manuals shows that the ultraSPARC-IIe is closely related to the ultraSPARC-IIi. I quote from the IIe userman: “Since the UltraSPARC IIe processor is very similar to the UltraSPARC IIi processor, the UltraSPARC IIi User’s Manual is a necessary companion to UltraSPARC IIe User’s Manual Supplement.. Normally, the UltraSPARC IIi User’s Manual is sufficient as a supplement.”

I am reading the book Solaris Internals 1st edition where majority covers Solaris 7. I maintain this blog post as a place to show the differences I have found along the way.

Solaris 7 data structure for an address space object:

struct as {
        kmutex_t a_contents;    /* protect certain fields in the structure */
        uchar_t  a_flags;       /* as attributes */
        uchar_t a_vbits;        /* used for collecting statistics */
        kcondvar_t a_cv;        /* used by as_rangelock */
        struct  hat *a_hat;     /* hat structure */
        struct  hrmstat *a_hrm; /* ref and mod bits */
        caddr_t a_userlimit;    /* highest allowable address in this as */
        union {
                struct seg *seglast;    /* last segment hit on the addr space */
                ssl_spath *spath;       /* last search path in seg skiplist */
        } a_cache;
        krwlock_t a_lock;       /* protects fields below + a_cache */
        int     a_nwpage;       /* number of watched pages */
        struct watched_page *a_wpage;   /* list of watched pages (procfs) */
        seg_next a_segs;        /* segments in this address space. */
        size_t  a_size;         /* size of address space */
        struct  seg *a_tail;    /* last element in the segment list. */
        uint_t  a_nsegs;        /* number of elements in segment list */
        uchar_t a_lrep;         /* representation of a_segs: see #defines */
        uchar_t a_hilevel;      /* highest level in the a_segs skiplist */
        uchar_t a_unused;
        uchar_t a_updatedir;    /* mappings changed, rebuild as_objectdir */
        vnode_t **a_objectdir;  /* object directory (procfs) */
        size_t  a_sizedir;      /* size of object directory */
};

Solaris 8:

struct as {
        kmutex_t a_contents;    /* protect certain fields in the structure */
        uchar_t  a_flags;       /* as attributes */
        uchar_t a_vbits;        /* used for collecting statistics */
        kcondvar_t a_cv;        /* used by as_rangelock */
        struct  hat *a_hat;     /* hat structure */
        struct  hrmstat *a_hrm; /* ref and mod bits */
        caddr_t a_userlimit;    /* highest allowable address in this as */
        union {
                struct seg *seglast;    /* last segment hit on the addr space */
                ssl_spath *spath;       /* last search path in seg skiplist */
        } a_cache;
        krwlock_t a_lock;       /* protects fields below + a_cache */
        int     a_nwpage;       /* number of watched pages */
        struct watched_page *a_wpage;   /* list of watched pages (procfs) */
        seg_next a_segs;        /* segments in this address space. */
        size_t  a_size;         /* size of address space */
        struct  seg *a_tail;    /* last element in the segment list. */
        uint_t  a_nsegs;        /* number of elements in segment list */
        uchar_t a_lrep;         /* representation of a_segs: see #defines */
        uchar_t a_hilevel;      /* highest level in the a_segs skiplist */
        uchar_t a_unused;
        uchar_t a_updatedir;    /* mappings changed, rebuild as_objectdir */
        vnode_t **a_objectdir;  /* object directory (procfs) */
        size_t  a_sizedir;      /* size of object directory */
        struct as_callback *a_callbacks; /* callback list */
};

Looks we have an extra callback structure in Solaris 8. Wonder what this is all about?

/*
 * The as_callback is the basic structure which supports the ability to
 * inform clients of specific events pertaining to address space management.
 * An example of the need for this is a driver which has done long-term
 * locking of memory.  Address space management operations (events) such
 * as as_free, as_umap, and as_setprot will block indefinitely until the
 * pertinent memory is unlocked.  The callback mechanism provides the
 * way to inform the driver of the event so that the driver may do the
 * necessary unlocking.
 *
 * The contents of this structure is protected by a_contents lock
 */
typedef void (*callback_func_t)(struct as *, void *, uint_t);
struct as_callback {
        struct as_callback      *ascb_next;             /* list link */
        int                     ascb_refcnt;            /* reference count   */
        uint_t                  ascb_events;            /* event types */
        callback_func_t         ascb_func;              /* callback function */
        void                    *ascb_arg;              /* callback argument */
        caddr_t                 ascb_saddr;             /* start address */
        size_t                  ascb_len;               /* address range */
};

Some grep things that I found handy:

man grep

Seriously. So yummy.

Some handy things that I’m using right now.

-A, -B, -C
print an arbitrary number of lines After, Before, or Before/After the matched string line. Super cool.

–no-filename, -h
Handy when you’re doing an grep -r but you expect 1 file to result. It can turn slop this like this:

bazz@blade72[pts/1][~] grep -r -C 10 "struct as {" /usr/include
/usr/include/vm/as.h- * operation.  Some segment drivers use the address space lock to protect
/usr/include/vm/as.h- * some or all of their segment private data, provided the version of
/usr/include/vm/as.h- * "a_lock" (read vs. write) is consistent with the use of the data.
/usr/include/vm/as.h- *
/usr/include/vm/as.h- * The following fields are protected by the hat layer lock:
/usr/include/vm/as.h- *
/usr/include/vm/as.h- * a_vbits
/usr/include/vm/as.h- * a_hat
/usr/include/vm/as.h- * a_hrm
/usr/include/vm/as.h- */
/usr/include/vm/as.h:struct as {
/usr/include/vm/as.h-   kmutex_t a_contents;    /* protect certain fields in the structure */
/usr/include/vm/as.h-   uchar_t  a_flags;       /* as attributes */
/usr/include/vm/as.h-   uchar_t a_vbits;        /* used for collecting statistics */
/usr/include/vm/as.h-   kcondvar_t a_cv;        /* used by as_rangelock */
/usr/include/vm/as.h-   struct  hat *a_hat;     /* hat structure */
/usr/include/vm/as.h-   struct  hrmstat *a_hrm; /* ref and mod bits */
/usr/include/vm/as.h-   caddr_t a_userlimit;    /* highest allowable address in this as */
/usr/include/vm/as.h-   union {
/usr/include/vm/as.h-           struct seg *seglast;    /* last segment hit on the addr space */
/usr/include/vm/as.h-           ssl_spath *spath;       /* last search path in seg skiplist */

into this

bazz@blade72[pts/1][~] grep -h -r -C 10 "struct as {" /usr/include
 * operation.  Some segment drivers use the address space lock to protect
 * some or all of their segment private data, provided the version of
 * "a_lock" (read vs. write) is consistent with the use of the data.
 *
 * The following fields are protected by the hat layer lock:
 *
 *      a_vbits
 *      a_hat
 *      a_hrm
 */
struct as {
        kmutex_t a_contents;    /* protect certain fields in the structure */
        uchar_t  a_flags;       /* as attributes */
        uchar_t a_vbits;        /* used for collecting statistics */
        kcondvar_t a_cv;        /* used by as_rangelock */
        struct  hat *a_hat;     /* hat structure */
        struct  hrmstat *a_hrm; /* ref and mod bits */
        caddr_t a_userlimit;    /* highest allowable address in this as */
        union {
                struct seg *seglast;    /* last segment hit on the addr space */
                ssl_spath *spath;       /* last search path in seg skiplist */

Ironically I think the first one looks better on the blog, but in the terminal, 2nd one is def preferred.

–with-filename, -H
forces inclusion of filename in result. In the case that you’re supporting grep that can find results for either one file itself and also more files (a flexible script), and you want to parse that grep result, you can use this to force consistency between the grep result for one file and for many files.

-n
Show line numbers

-r
recursive grep search. SUPER USEFUL

When I use -r -H -n together, grep gives a colon-delimeted grep output

filename:line#:matched-line

You can use cut to work with this. ie | cut -f2 -d: to grab the line#

Other important notes
environment variables can take results with newlines on them, it’s just that in order to process that you need to make sure you embed that $var inside quotes “$var” or it will be instead interpreted as all spaces for new lines.

tail +$linenum $filename | head -n $endlinenum | tee /tmp/struct

This in english: I want to print from line $linenum and only print $endlinenum lines. Send this output to a file /tmp/struct and to stdout.

Looking for the struct in /usr/include

[pts/3][~] grep -r "struct as {" /usr/include
/usr/include/vm/as.h:struct as {

Notice that we have here a colon delimited filename:line match
Although we did a recursive search we don’t expect to find more than 1 match.

I would really like to be able to query the whole struct, and here’s how I can do that:
this will find the file, and “less” it at the exact position of the struct.

Note: cool command while using less: the { and } keys will bring you to the matching end and beginning curly brace respectively. { -> goto matching end brace } -> goto matching beginning brace

Note: I just slapped this together and I’m willing to share but take note that my comments below are in-dev comments and may not even make sense or apply to you or the script at all. Nope not taking ’em out :P

#!/home/bazz/tools/bin/bash
# struct finder
# does not yet support multiple file search results
# example usage: ./derp /usr/include "struct as {"

if [ "$1" = "" ]; then
  echo "usage: `basename $0` [dir] [search-str]"
  exit 1
fi


# this needs to come out of var, into xargs invocation
grepline="`grep --with-filename -n -r \"$2\" \"$1\"`"
# /usr/include/vm/as.h:113:struct as {
#echo "$grepline"

wcount="`wc -l <<< \"$grepline\"`"
# wc puts whitespace into the output so we remove that
wc=${wcount//[[:blank:]]/}

#echo "$wc"
if [ "$wc" -gt "1" ]; then
  echo 'Be more specific'
  exit 2
fi
# xargs will invoke this downwards as a function
filename="`echo $grepline | cut -f1 -d:`"
linenum="`echo $grepline | cut -f2 -d:`"

less +$linenum $filename
exit 0


>&2 echo "filename = $filename"
>&2 echo "linenum = $linenum"
endlinenums="`tail +$linenum $filename | grep -n '};'`"
wordcount="`wc -w <<<$endlinenums`"
wc=${wordcount//[[:blank:]]/}
>&2 echo "$endlinenums"
>&2 echo "$wc"

for i in `seq 1 $wc`; do
  cur="`cut -f$i -d' ' <<<$endlinenums`"
  #echo "$cur"
  endlinenum="`cut -f1 -d: <<< $cur`"
  #echo $endlinenum
  #linediff=$(( endlinenum - linenum ))
  #echo "linediff = $linediff"
  tail +$linenum $filename | head -n $endlinenum | tee /tmp/struct
  >&2 printf "is that right? (y/n): "
  read -n1 yn
  echo
  if [ "$yn" == "y" ]; then
    echo 'saved in /tmp/struct'
    exit 0
  fi
done

echo 'we failed :('
exit 1