You were very close! So close that it's difficult to spot what's different in the fixed version. Your original version would have worked if you had iterated over the keys of %$innerHash instead of the keys of the (non-existent) %innerHash; i.e.:

while(($hostname, $innerHash) = each(%listOfHostsWithProblems)) {
 foreach $type (keys %$innerHash)
   {
     print $listOfHostsWithProblems{$hostname}->{$type} . "\n";
     print "yo";
   }
}
[download]

That's why you should run things under use strict; it would have told right away that %innerHash did not exist.

BTW, $listOfHostsWithProblems{$hostname} and $innerHash are the same thing, except that the former entails one more hash lookup, so the first print statement could have been written more efficiently as

  print $innerHash->{ $type } . "\n";
[download]

You see, we usually call these data structures "hashes of hashes", but it may be more accurate to call them "hashes of hash references," because the values of a HoH are hash references, not hashes. (Similarly, "arrays of arrays" are really "arrays of array references", "arrays of hashes" are really "arrays of hash references", etc.) This is because the values of a hash (and the members of an array) must be scalars. Hence, to get around this restriction, we use references (which are always scalars irrespective of what they point to) to hashes (or arrays, etc.) when we want to "store" a hash in another hash (or in an array). The same considerations apply to HoHoHs, HoAoH's, AoHoHoAs, and any other combination you may want to dream up. E.g. a HoAoH is a "hash whose values are array references pointing to arrays whose members are hash references". But returning to your code, this all means that $listOfHostsWithProblems{$hostname} is a hash reference, $innerHash, not a hash. That's where you went wrong.

Update: Added last paragraph.