Improve ARC hit rate with metadata heavy workloads

```
This stack of patches has been empirically shown to drastically improve         
the hit rate of the ARC for certain workloads. As a result, fewer reads         
to disk are required, which is generally a good thing and can                   
drastically improve performance if the workload is disk limited.                
                                                                                
For the impatient, I'll summarize the results of the tests performed:           
                                                                                
    * Test 1 - Creating many empty directories. This test saw 99.9%             
               fewer reads and 12.8% more inodes created when running           
               *with* these changes.                                            
                                                                                
    * Test 2 - Creating many empty files. This test saw 4% fewer reads          
               and 0% more inodes created when running *with* these             
               changes.                                                         
                                                                                
    * Test 3 - Creating many 4 KiB files. This test saw 96.7% fewer             
               reads and 4.9% more inodes created when running *with*           
               these changes.                                                   
                                                                                
    * Test 4 - Creating many 4096 KiB files. This test saw 99.4% fewer          
               reads and 0% more inodes created (but took 6.9% fewer            
               seconds to complete) when running *with* these changes.                                              
                                                                                
    * Test 5 - Rsync'ing a dataset with many empty directories. This            
               test saw 36.2% fewer reads and 66.2% more inodes created         
               when running *with* these changes.                               
                                                                                
    * Test 6 - Rsync'ing a dataset with many empty files. This test saw         
               30.9% fewer reads and 0% more inodes created (but took           
               24.3% fewer seconds to complete) when running *with*             
               these changes.                                                   
                                                                                
    * Test 7 - Rsync'ing a dataset with many 4 KiB files. This test saw         
               30.8% fewer reads and 173.3% more inodes created when            
               running *with* these changes.                                    
                                                                                
For the patient, the following consists of more a more detailed                 
description of the tests performed and the results gathered.                    
                                                                                
All the tests were run using identical machines, each with a pool               
consisting of 5 mirror pairs with 2TB 7200 RPM disks. Each test was run         
twice, once *without* this set of patches and again *with* this set of          
patches to highlight the performance changes introduced. The first four         
workloads tested were:                                                          
                                                                                
    ** NOTE: None of these tests were run to completion. They ran for a         
             set amount of time and then were terminated or hit ENOSPC.         
                                                                                
    1. Creating many empty directories:                                         
                                                                                
       * fdtree -d 10 -l 8 -s 0 -f 0 -C                                         
         -> 111,111,111 Directories                                             
         ->           0 Files                                                   
         ->           0 KiB File Data                                           
                                                                                
    2. Creating many empty files:                                               
                                                                                
       * fdtree -d 10 -l 5 -s 0 -f 10000 -C                                     
         ->       111,111 Directories                                           
         -> 1,111,110,000 Files                                                 
         ->             0 KiB File Data                                         
                                                                                
    3. Creating many 4 KiB files:                                               
                                                                                
       * fdtree -d 10 -l 5 -s 1 -f 10000 -C                                     
         ->       111,111 Directories                                           
         -> 1,111,110,000 Files                                                 
         -> 4,444,440,000 KiB File Data                                         
                                                                                
    4. Creating many 4096 KiB files:                                            
                                                                                
       * fdtree -d 10 -l 5 -s 1024 -f 10000 -C                                  
         ->           111,111 Directories                                       
         ->     1,111,110,000 Files                                             
         -> 4,551,106,560,000 KiB File Data                                     
                                                                                
Results for these first four tests are below:                                   
                                                                                
                  | Time (s) |   inodes |  reads |    writes |                  
                --+----------+----------+--------+-----------+                  
    Test 1 Before |    65069 | 37845363 | 831975 |   3214646 |                  
    Test 1 After  |    65069 | 42703608 |    778 |   3327674 |                  
                --+----------+----------+--------+-----------+                  
    Test 2 Before |    65073 | 54257583 | 208647 |   2413056 |                  
    Test 2 After  |    65069 | 54255782 | 200038 |   2533759 |                  
                --+----------+----------+--------+-----------+                  
    Test 3 Before |    65068 | 49857744 | 487130 |   5533348 |                  
    Test 3 After  |    65071 | 52294311 |  16078 |   5648354 |                  
                --+----------+----------+--------+-----------+                  
    Test 4 Before |    34854 |  2448329 | 385870 | 162116572 |                  
    Test 4 After  |    32419 |  2448329 |   2339 | 162175706 |                  
                --+----------+----------+--------+-----------+                  
                                                                                
    * "Time (s)" - The run time of the test in seconds                          
    * "inodes"   - The number of inodes created by the test                     
    * "reads"    - The number of reads performed by the test                    
    * "writes"   - The number of writes performed by the test

As you can see from the table above, running with this patch stack              
*significantly* reduced the number of reads performed in 3 out of the 4         
tests (due to an improved ARC hit rate).                                        
                                                                                
In addition to the tests described above, which specifically targeted           
creates only, three other workloads were tested. These additional tests         
were targeting rsync performance against the datasets created in the            
previous tests. A brief description of the workloads and results for            
these tests are below:                                                          
                                                                                
    ** NOTE: Aside from (6), these tests didn't run to completion. They         
             ran for a set amount of time and then were terminated.             
                                                                                
    5. Rsync the dataset created in Test 1 to a new dataset:                    
                                                                                
       * rsync -a /tank/test-1 /tank/test-5                                     
                                                                                
    6. Rsync the dataset created in Test 2 to a new dataset:                    
                                                                                
       * rsync -a /tank/test-2 /tank/test-6                                     
                                                                                
    7. Rsync the dataset created in Test 3 to a new dataset:                    
                                                                                
       * rsync -a /tank/test-3 /tank/test-7                                     
                                                                                
Results for Test 5, 6, and 7 are below:                                         
                                                                                
                  | Time (s) |   inodes |    reads |  writes |                  
                --+----------+----------+----------+---------+                  
    Test 5 Before |    93041 | 17921014 | 47632823 | 4094848 |                  
    Test 5 After  |    93029 | 29785847 | 30376206 | 4484459 |                  
                --+----------+----------+----------+---------+                  
    Test 6 Before |    15290 | 54264474 |  6018331 |  733087 |                  
    Test 6 After  |    11573 | 54260826 |  4155661 |  617285 |                  
                --+----------+----------+----------+---------+                  
    Test 7 Before |    93057 | 10093749 | 41561635 | 3659098 |                  
    Test 7 After  |    93045 | 27587043 | 28773151 | 5612234 |                  
                --+----------+----------+----------+---------+                  
                                                                                
    * "Time (s)" - The run time of the test in seconds                          
    * "inodes"   - The number of inodes created by the test                     
    * "reads"    - The number of reads performed by the test                    
    * "writes"   - The number of writes performed by the test                   
                                                                                
Signed-off-by: Prakash Surya <surya1@llnl.gov>
```