9 files changed, 581 insertions, 117 deletions

diff --git a/Documentation/SubmitChecklist b/Documentation/SubmitChecklist
index bd23dc0bc0c7..6491b2c45dd4 100644
--- a/Documentation/SubmitChecklist
+++ b/Documentation/SubmitChecklist
@@ -80,3 +80,7 @@ kernel patches.
 23: Tested after it has been merged into the -mm patchset to make sure
     that it still works with all of the other queued patches and various
     changes in the VM, VFS, and other subsystems.
+
+24: Avoid whitespace damage such as indenting with spaces or whitespace
+    at the end of lines.  You can test this by feeding the patch to
+    "git apply --check --whitespace=error-all"
diff --git a/Documentation/SubmittingPatches b/Documentation/SubmittingPatches
index b0d0043f7c46..a417b25fb1aa 100644
--- a/Documentation/SubmittingPatches
+++ b/Documentation/SubmittingPatches
@@ -363,7 +363,8 @@ area or subsystem of the kernel is being patched.
 The "summary phrase" in the email's Subject should concisely
 describe the patch which that email contains.  The "summary
 phrase" should not be a filename.  Do not use the same "summary
-phrase" for every patch in a whole patch series.
+phrase" for every patch in a whole patch series (where a "patch
+series" is an ordered sequence of multiple, related patches).
 
 Bear in mind that the "summary phrase" of your email becomes
 a globally-unique identifier for that patch.  It propagates
diff --git a/Documentation/cpu-hotplug.txt b/Documentation/cpu-hotplug.txt
index cc60d29b954c..b6d24c22274b 100644
--- a/Documentation/cpu-hotplug.txt
+++ b/Documentation/cpu-hotplug.txt
@@ -217,14 +217,17 @@ Q: What happens when a CPU is being logically offlined?
 A: The following happen, listed in no particular order :-)
 
 - A notification is sent to in-kernel registered modules by sending an event
-  CPU_DOWN_PREPARE
+  CPU_DOWN_PREPARE or CPU_DOWN_PREPARE_FROZEN, depending on whether or not the
+  CPU is being offlined while tasks are frozen due to a suspend operation in
+  progress
 - All process is migrated away from this outgoing CPU to a new CPU
 - All interrupts targeted to this CPU is migrated to a new CPU
 - timers/bottom half/task lets are also migrated to a new CPU
 - Once all services are migrated, kernel calls an arch specific routine
   __cpu_disable() to perform arch specific cleanup.
 - Once this is successful, an event for successful cleanup is sent by an event
-  CPU_DEAD.
+  CPU_DEAD (or CPU_DEAD_FROZEN if tasks are frozen due to a suspend while the
+  CPU is being offlined).
 
   "It is expected that each service cleans up when the CPU_DOWN_PREPARE
   notifier is called, when CPU_DEAD is called its expected there is nothing
@@ -242,9 +245,11 @@ A: This is what you would need in your kernel code to receive notifications.
 
                 switch (action) {
                 case CPU_ONLINE:
+                case CPU_ONLINE_FROZEN:
                         foobar_online_action(cpu);
                         break;
                 case CPU_DEAD:
+                case CPU_DEAD_FROZEN:
                         foobar_dead_action(cpu);
                         break;
                 }
diff --git a/Documentation/device-mapper/delay.txt b/Documentation/device-mapper/delay.txt
new file mode 100644
index 000000000000..15adc55359e5
--- /dev/null
+++ b/Documentation/device-mapper/delay.txt
@@ -0,0 +1,26 @@
+dm-delay
+========
+
+Device-Mapper's "delay" target delays reads and/or writes
+and maps them to different devices.
+
+Parameters:
+    <device> <offset> <delay> [<write_device> <write_offset> <write_delay>]
+
+With separate write parameters, the first set is only used for reads.
+Delays are specified in milliseconds.
+
+Example scripts
+===============
+[[
+#!/bin/sh
+# Create device delaying rw operation for 500ms
+echo "0 `blockdev --getsize $1` delay $1 0 500" | dmsetup create delayed
+]]
+
+[[
+#!/bin/sh
+# Create device delaying only write operation for 500ms and
+# splitting reads and writes to different devices $1 $2
+echo "0 `blockdev --getsize $1` delay $1 0 0 $2 0 500" | dmsetup create delayed
+]]
diff --git a/Documentation/fb/arkfb.txt b/Documentation/fb/arkfb.txt
new file mode 100644
index 000000000000..e8487a9d6a05
--- /dev/null
+++ b/Documentation/fb/arkfb.txt
@@ -0,0 +1,68 @@
+
+        arkfb - fbdev driver for ARK Logic chips
+        ========================================
+
+
+Supported Hardware
+==================
+
+        ARK 2000PV chip
+        ICS 5342 ramdac
+
+        - only BIOS initialized VGA devices supported
+        - probably not working on big endian
+
+
+Supported Features
+==================
+
+        *  4 bpp pseudocolor modes (with 18bit palette, two variants)
+        *  8 bpp pseudocolor mode (with 18bit palette)
+        * 16 bpp truecolor modes (RGB 555 and RGB 565)
+        * 24 bpp truecolor mode (RGB 888)
+        * 32 bpp truecolor mode (RGB 888)
+        * text mode (activated by bpp = 0)
+        * doublescan mode variant (not available in text mode)
+        * panning in both directions
+        * suspend/resume support
+
+Text mode is supported even in higher resolutions, but there is limitation to
+lower pixclocks (i got maximum about 70 MHz, it is dependent on specific
+hardware). This limitation is not enforced by driver. Text mode supports 8bit
+wide fonts only (hardware limitation) and 16bit tall fonts (driver
+limitation). Unfortunately character attributes (like color) in text mode are
+broken for unknown reason, so its usefulness is limited.
+
+There are two 4 bpp modes. First mode (selected if nonstd == 0) is mode with
+packed pixels, high nibble first. Second mode (selected if nonstd == 1) is mode
+with interleaved planes (1 byte interleave), MSB first. Both modes support
+8bit wide fonts only (driver limitation).
+
+Suspend/resume works on systems that initialize video card during resume and
+if device is active (for example used by fbcon).
+
+
+Missing Features
+================
+(alias TODO list)
+
+        * secondary (not initialized by BIOS) device support
+        * big endian support
+        * DPMS support
+        * MMIO support
+        * interlaced mode variant
+        * support for fontwidths != 8 in 4 bpp modes
+        * support for fontheight != 16 in text mode
+        * hardware cursor
+        * vsync synchronization
+        * feature connector support
+        * acceleration support (8514-like 2D)
+
+
+Known bugs
+==========
+
+        * character attributes (and cursor) in text mode are broken
+
+--
+Ondrej Zajicek <santiago@crfreenet.org>
diff --git a/Documentation/fb/vt8623fb.txt b/Documentation/fb/vt8623fb.txt
new file mode 100644
index 000000000000..f654576c56b7
--- /dev/null
+++ b/Documentation/fb/vt8623fb.txt
@@ -0,0 +1,64 @@
+
+        vt8623fb - fbdev driver for graphics core in VIA VT8623 chipset
+        ===============================================================
+
+
+Supported Hardware
+==================
+
+        VIA VT8623 [CLE266] chipset and its graphics core
+                (known as CastleRock or Unichrome)
+
+I tested vt8623fb on VIA EPIA ML-6000
+
+
+Supported Features
+==================
+
+        *  4 bpp pseudocolor modes (with 18bit palette, two variants)
+        *  8 bpp pseudocolor mode (with 18bit palette)
+        * 16 bpp truecolor mode (RGB 565)
+        * 32 bpp truecolor mode (RGB 888)
+        * text mode (activated by bpp = 0)
+        * doublescan mode variant (not available in text mode)
+        * panning in both directions
+        * suspend/resume support
+        * DPMS support
+
+Text mode is supported even in higher resolutions, but there is limitation to
+lower pixclocks (maximum about 100 MHz). This limitation is not enforced by
+driver. Text mode supports 8bit wide fonts only (hardware limitation) and
+16bit tall fonts (driver limitation).
+
+There are two 4 bpp modes. First mode (selected if nonstd == 0) is mode with
+packed pixels, high nibble first. Second mode (selected if nonstd == 1) is mode
+with interleaved planes (1 byte interleave), MSB first. Both modes support
+8bit wide fonts only (driver limitation).
+
+Suspend/resume works on systems that initialize video card during resume and
+if device is active (for example used by fbcon).
+
+
+Missing Features
+================
+(alias TODO list)
+
+        * secondary (not initialized by BIOS) device support
+        * MMIO support
+        * interlaced mode variant
+        * support for fontwidths != 8 in 4 bpp modes
+        * support for fontheight != 16 in text mode
+        * hardware cursor
+        * video overlay support
+        * vsync synchronization
+        * acceleration support (8514-like 2D, busmaster transfers)
+
+
+Known bugs
+==========
+
+        * cursor disable in text mode doesn't work
+
+
+--
+Ondrej Zajicek <santiago@crfreenet.org>
diff --git a/Documentation/md.txt b/Documentation/md.txt
index 2202f5dc8ac2..5818628207b5 100644
--- a/Documentation/md.txt
+++ b/Documentation/md.txt
@@ -178,6 +178,21 @@ All md devices contain:
      The size should be at least PAGE_SIZE (4k) and should be a power
      of 2.  This can only be set while assembling an array
 
+  layout
+     The "layout" for the array for the particular level.  This is
+     simply a number that is interpretted differently by different
+     levels.  It can be written while assembling an array.
+
+  reshape_position
+     This is either "none" or a sector number within the devices of
+     the array where "reshape" is up to.  If this is set, the three
+     attributes mentioned above (raid_disks, chunk_size, layout) can
+     potentially have 2 values, an old and a new value.  If these
+     values differ, reading the attribute returns
+        new (old)
+     and writing will effect the 'new' value, leaving the 'old'
+     unchanged.
+
   component_size
      For arrays with data redundancy (i.e. not raid0, linear, faulty,
      multipath), all components must be the same size - or at least
@@ -193,11 +208,6 @@ All md devices contain:
      1.2 (newer format in varying locations) or "none" indicating that
      the kernel isn't managing metadata at all.
 
-  layout
-     The "layout" for the array for the particular level.  This is
-     simply a number that is interpretted differently by different
-     levels.  It can be written while assembling an array.
-
   resync_start
      The point at which resync should start.  If no resync is needed,
      this will be a very large number.  At array creation it will
@@ -259,29 +269,6 @@ All md devices contain:
          like active, but no writes have been seen for a while (safe_mode_delay).
 
 
-   sync_speed_min
-   sync_speed_max
-     This are similar to /proc/sys/dev/raid/speed_limit_{min,max}
-     however they only apply to the particular array.
-     If no value has been written to these, of if the word 'system'
-     is written, then the system-wide value is used.  If a value,
-     in kibibytes-per-second is written, then it is used.
-     When the files are read, they show the currently active value
-     followed by "(local)" or "(system)" depending on whether it is
-     a locally set or system-wide value.
-
-   sync_completed
-     This shows the number of sectors that have been completed of
-     whatever the current sync_action is, followed by the number of
-     sectors in total that could need to be processed.  The two
-     numbers are separated by a '/'  thus effectively showing one
-     value, a fraction of the process that is complete.
-
-   sync_speed
-     This shows the current actual speed, in K/sec, of the current
-     sync_action.  It is averaged over the last 30 seconds.
-
-
 As component devices are added to an md array, they appear in the 'md'
 directory as new directories named
       dev-XXX
@@ -412,6 +399,35 @@ also have
       Note that the numbers are 'bit' numbers, not 'block' numbers.
       They should be scaled by the bitmap_chunksize.
 
+   sync_speed_min
+   sync_speed_max
+     This are similar to /proc/sys/dev/raid/speed_limit_{min,max}
+     however they only apply to the particular array.
+     If no value has been written to these, of if the word 'system'
+     is written, then the system-wide value is used.  If a value,
+     in kibibytes-per-second is written, then it is used.
+     When the files are read, they show the currently active value
+     followed by "(local)" or "(system)" depending on whether it is
+     a locally set or system-wide value.
+
+   sync_completed
+     This shows the number of sectors that have been completed of
+     whatever the current sync_action is, followed by the number of
+     sectors in total that could need to be processed.  The two
+     numbers are separated by a '/'  thus effectively showing one
+     value, a fraction of the process that is complete.
+
+   sync_speed
+     This shows the current actual speed, in K/sec, of the current
+     sync_action.  It is averaged over the last 30 seconds.
+
+   suspend_lo
+   suspend_hi
+     The two values, given as numbers of sectors, indicate a range
+     within the array where IO will be blocked.  This is currently
+     only supported for raid4/5/6.
+
+
 Each active md device may also have attributes specific to the
 personality module that manages it.
 These are specific to the implementation of the module and could
diff --git a/Documentation/power/userland-swsusp.txt b/Documentation/power/userland-swsusp.txt
index 000556c932e9..e00c6cf09e85 100644
--- a/Documentation/power/userland-swsusp.txt
+++ b/Documentation/power/userland-swsusp.txt
@@ -93,21 +93,23 @@ SNAPSHOT_S2RAM - suspend to RAM; using this call causes the kernel to
         to resume the system from RAM if there's enough battery power or restore
         its state on the basis of the saved suspend image otherwise)
 
-SNAPSHOT_PMOPS - enable the usage of the pmops->prepare, pmops->enter and
-        pmops->finish methods (the in-kernel swsusp knows these as the "platform
-        method") which are needed on many machines to (among others) speed up
-        the resume by letting the BIOS skip some steps or to let the system
-        recognise the correct state of the hardware after the resume (in
-        particular on many machines this ensures that unplugged AC
-        adapters get correctly detected and that kacpid does not run wild after
-        the resume).  The last ioctl() argument can take one of the three
-        values, defined in kernel/power/power.h:
+SNAPSHOT_PMOPS - enable the usage of the hibernation_ops->prepare,
+        hibernate_ops->enter and hibernation_ops->finish methods (the in-kernel
+        swsusp knows these as the "platform method") which are needed on many
+        machines to (among others) speed up the resume by letting the BIOS skip
+        some steps or to let the system recognise the correct state of the
+        hardware after the resume (in particular on many machines this ensures
+        that unplugged AC adapters get correctly detected and that kacpid does
+        not run wild after the resume).  The last ioctl() argument can take one
+        of the three values, defined in kernel/power/power.h:
         PMOPS_PREPARE - make the kernel carry out the
-                pm_ops->prepare(PM_SUSPEND_DISK) operation
+                hibernation_ops->prepare() operation
         PMOPS_ENTER - make the kernel power off the system by calling
-                pm_ops->enter(PM_SUSPEND_DISK)
+                hibernation_ops->enter()
         PMOPS_FINISH - make the kernel carry out the
-                pm_ops->finish(PM_SUSPEND_DISK) operation
+                hibernation_ops->finish() operation
+        Note that the actual constants are misnamed because they surface
+        internal kernel implementation details that have changed.
 
 The device's read() operation can be used to transfer the snapshot image from
 the kernel.  It has the following limitations:
diff --git a/Documentation/vm/slabinfo.c b/Documentation/vm/slabinfo.c
index 41710ccf3a29..686a8e04a4f3 100644
--- a/Documentation/vm/slabinfo.c
+++ b/Documentation/vm/slabinfo.c
@@ -16,6 +16,7 @@
 #include <stdarg.h>
 #include <getopt.h>
 #include <regex.h>
+#include <errno.h>
 
 #define MAX_SLABS 500
 #define MAX_ALIASES 500
@@ -41,12 +42,15 @@ struct aliasinfo {
 } aliasinfo[MAX_ALIASES];
 
 int slabs = 0;
+int actual_slabs = 0;
 int aliases = 0;
 int alias_targets = 0;
 int highest_node = 0;
 
 char buffer[4096];
 
+int show_empty = 0;
+int show_report = 0;
 int show_alias = 0;
 int show_slab = 0;
 int skip_zero = 1;
@@ -59,6 +63,15 @@ int show_inverted = 0;
 int show_single_ref = 0;
 int show_totals = 0;
 int sort_size = 0;
+int set_debug = 0;
+int show_ops = 0;
+
+/* Debug options */
+int sanity = 0;
+int redzone = 0;
+int poison = 0;
+int tracking = 0;
+int tracing = 0;
 
 int page_size;
 
@@ -76,20 +89,33 @@ void fatal(const char *x, ...)
 
 void usage(void)
 {
-        printf("slabinfo [-ahnpvtsz] [slab-regexp]\n"
+        printf("slabinfo 5/7/2007. (c) 2007 sgi. clameter@sgi.com\n\n"
+                "slabinfo [-ahnpvtsz] [-d debugopts] [slab-regexp]\n"
                 "-a|--aliases           Show aliases\n"
+                "-d<options>|--debug=<options> Set/Clear Debug options\n"
+                "-e|--empty             Show empty slabs\n"
+                "-f|--first-alias       Show first alias\n"
                 "-h|--help              Show usage information\n"
+                "-i|--inverted          Inverted list\n"
+                "-l|--slabs             Show slabs\n"
                 "-n|--numa              Show NUMA information\n"
+                "-o|--ops               Show kmem_cache_ops\n"
                 "-s|--shrink            Shrink slabs\n"
-                "-v|--validate          Validate slabs\n"
+                "-r|--report            Detailed report on single slabs\n"
+                "-S|--Size              Sort by size\n"
                 "-t|--tracking          Show alloc/free information\n"
                 "-T|--Totals            Show summary information\n"
-                "-l|--slabs             Show slabs\n"
-                "-S|--Size              Sort by size\n"
+                "-v|--validate          Validate slabs\n"
                 "-z|--zero              Include empty slabs\n"
-                "-f|--first-alias       Show first alias\n"
-                "-i|--inverted          Inverted list\n"
                 "-1|--1ref              Single reference\n"
+                "\nValid debug options (FZPUT may be combined)\n"
+                "a / A          Switch on all debug options (=FZUP)\n"
+                "-              Switch off all debug options\n"
+                "f / F          Sanity Checks (SLAB_DEBUG_FREE)\n"
+                "z / Z          Redzoning\n"
+                "p / P          Poisoning\n"
+                "u / U          Tracking\n"
+                "t / T          Tracing\n"
         );
 }
 
@@ -143,11 +169,10 @@ unsigned long get_obj_and_str(char *name, char **x)
 void set_obj(struct slabinfo *s, char *name, int n)
 {
         char x[100];
+        FILE *f;
 
         sprintf(x, "%s/%s", s->name, name);
-
-        FILE *f = fopen(x, "w");
-
+        f = fopen(x, "w");
         if (!f)
                 fatal("Cannot write to %s\n", x);
 
@@ -155,6 +180,26 @@ void set_obj(struct slabinfo *s, char *name, int n)
         fclose(f);
 }
 
+unsigned long read_slab_obj(struct slabinfo *s, char *name)
+{
+        char x[100];
+        FILE *f;
+        int l;
+
+        sprintf(x, "%s/%s", s->name, name);
+        f = fopen(x, "r");
+        if (!f) {
+                buffer[0] = 0;
+                l = 0;
+        } else {
+                l = fread(buffer, 1, sizeof(buffer), f);
+                buffer[l] = 0;
+                fclose(f);
+        }
+        return l;
+}
+
+
 /*
  * Put a size string together
  */
@@ -226,7 +271,7 @@ int line = 0;
 
 void first_line(void)
 {
-        printf("Name                 Objects   Objsize    Space "
+        printf("Name                   Objects Objsize    Space "
                 "Slabs/Part/Cpu  O/S O %%Fr %%Ef Flg\n");
 }
 
@@ -246,10 +291,7 @@ struct aliasinfo *find_one_alias(struct slabinfo *find)
                                         return best;
                         }
         }
-        if (best)
-                return best;
-        fatal("Cannot find alias for %s\n", find->name);
-        return NULL;
+        return best;
 }
 
 unsigned long slab_size(struct slabinfo *s)
@@ -257,6 +299,126 @@ unsigned long slab_size(struct slabinfo *s)
         return  s->slabs * (page_size << s->order);
 }
 
+void slab_numa(struct slabinfo *s, int mode)
+{
+        int node;
+
+        if (strcmp(s->name, "*") == 0)
+                return;
+
+        if (!highest_node) {
+                printf("\n%s: No NUMA information available.\n", s->name);
+                return;
+        }
+
+        if (skip_zero && !s->slabs)
+                return;
+
+        if (!line) {
+                printf("\n%-21s:", mode ? "NUMA nodes" : "Slab");
+                for(node = 0; node <= highest_node; node++)
+                        printf(" %4d", node);
+                printf("\n----------------------");
+                for(node = 0; node <= highest_node; node++)
+                        printf("-----");
+                printf("\n");
+        }
+        printf("%-21s ", mode ? "All slabs" : s->name);
+        for(node = 0; node <= highest_node; node++) {
+                char b[20];
+
+                store_size(b, s->numa[node]);
+                printf(" %4s", b);
+        }
+        printf("\n");
+        if (mode) {
+                printf("%-21s ", "Partial slabs");
+                for(node = 0; node <= highest_node; node++) {
+                        char b[20];
+
+                        store_size(b, s->numa_partial[node]);
+                        printf(" %4s", b);
+                }
+                printf("\n");
+        }
+        line++;
+}
+
+void show_tracking(struct slabinfo *s)
+{
+        printf("\n%s: Kernel object allocation\n", s->name);
+        printf("-----------------------------------------------------------------------\n");
+        if (read_slab_obj(s, "alloc_calls"))
+                printf(buffer);
+        else
+                printf("No Data\n");
+
+        printf("\n%s: Kernel object freeing\n", s->name);
+        printf("------------------------------------------------------------------------\n");
+        if (read_slab_obj(s, "free_calls"))
+                printf(buffer);
+        else
+                printf("No Data\n");
+
+}
+
+void ops(struct slabinfo *s)
+{
+        if (strcmp(s->name, "*") == 0)
+                return;
+
+        if (read_slab_obj(s, "ops")) {
+                printf("\n%s: kmem_cache operations\n", s->name);
+                printf("--------------------------------------------\n");
+                printf(buffer);
+        } else
+                printf("\n%s has no kmem_cache operations\n", s->name);
+}
+
+const char *onoff(int x)
+{
+        if (x)
+                return "On ";
+        return "Off";
+}
+
+void report(struct slabinfo *s)
+{
+        if (strcmp(s->name, "*") == 0)
+                return;
+        printf("\nSlabcache: %-20s  Aliases: %2d Order : %2d\n", s->name, s->aliases, s->order);
+        if (s->hwcache_align)
+                printf("** Hardware cacheline aligned\n");
+        if (s->cache_dma)
+                printf("** Memory is allocated in a special DMA zone\n");
+        if (s->destroy_by_rcu)
+                printf("** Slabs are destroyed via RCU\n");
+        if (s->reclaim_account)
+                printf("** Reclaim accounting active\n");
+
+        printf("\nSizes (bytes)     Slabs              Debug                Memory\n");
+        printf("------------------------------------------------------------------------\n");
+        printf("Object : %7d  Total  : %7ld   Sanity Checks : %s  Total: %7ld\n",
+                        s->object_size, s->slabs, onoff(s->sanity_checks),
+                        s->slabs * (page_size << s->order));
+        printf("SlabObj: %7d  Full   : %7ld   Redzoning     : %s  Used : %7ld\n",
+                        s->slab_size, s->slabs - s->partial - s->cpu_slabs,
+                        onoff(s->red_zone), s->objects * s->object_size);
+        printf("SlabSiz: %7d  Partial: %7ld   Poisoning     : %s  Loss : %7ld\n",
+                        page_size << s->order, s->partial, onoff(s->poison),
+                        s->slabs * (page_size << s->order) - s->objects * s->object_size);
+        printf("Loss   : %7d  CpuSlab: %7d   Tracking      : %s  Lalig: %7ld\n",
+                        s->slab_size - s->object_size, s->cpu_slabs, onoff(s->store_user),
+                        (s->slab_size - s->object_size) * s->objects);
+        printf("Align  : %7d  Objects: %7d   Tracing       : %s  Lpadd: %7ld\n",
+                        s->align, s->objs_per_slab, onoff(s->trace),
+                        ((page_size << s->order) - s->objs_per_slab * s->slab_size) *
+                        s->slabs);
+
+        ops(s);
+        show_tracking(s);
+        slab_numa(s, 1);
+}
 
 void slabcache(struct slabinfo *s)
 {
@@ -265,7 +427,18 @@ void slabcache(struct slabinfo *s)
         char flags[20];
         char *p = flags;
 
-        if (skip_zero && !s->slabs)
+        if (strcmp(s->name, "*") == 0)
+                return;
+
+        if (actual_slabs == 1) {
+                report(s);
+                return;
+        }
+
+        if (skip_zero && !show_empty && !s->slabs)
+                return;
+
+        if (show_empty && s->slabs)
                 return;
 
         store_size(size_str, slab_size(s));
@@ -303,48 +476,128 @@ void slabcache(struct slabinfo *s)
                 flags);
 }
 
-void slab_numa(struct slabinfo *s)
+/*
+ * Analyze debug options. Return false if something is amiss.
+ */
+int debug_opt_scan(char *opt)
 {
-        int node;
+        if (!opt || !opt[0] || strcmp(opt, "-") == 0)
+                return 1;
+
+        if (strcasecmp(opt, "a") == 0) {
+                sanity = 1;
+                poison = 1;
+                redzone = 1;
+                tracking = 1;
+                return 1;
+        }
 
-        if (!highest_node)
-                fatal("No NUMA information available.\n");
+        for ( ; *opt; opt++)
+                switch (*opt) {
+                case 'F' : case 'f':
+                        if (sanity)
+                                return 0;
+                        sanity = 1;
+                        break;
+                case 'P' : case 'p':
+                        if (poison)
+                                return 0;
+                        poison = 1;
+                        break;
 
-        if (skip_zero && !s->slabs)
-                return;
+                case 'Z' : case 'z':
+                        if (redzone)
+                                return 0;
+                        redzone = 1;
+                        break;
 
-        if (!line) {
-                printf("\nSlab             Node ");
-                for(node = 0; node <= highest_node; node++)
-                        printf(" %4d", node);
-                printf("\n----------------------");
-                for(node = 0; node <= highest_node; node++)
-                        printf("-----");
-                printf("\n");
-        }
-        printf("%-21s ", s->name);
-        for(node = 0; node <= highest_node; node++) {
-                char b[20];
+                case 'U' : case 'u':
+                        if (tracking)
+                                return 0;
+                        tracking = 1;
+                        break;
 
-                store_size(b, s->numa[node]);
-                printf(" %4s", b);
-        }
-        printf("\n");
-        line++;
+                case 'T' : case 't':
+                        if (tracing)
+                                return 0;
+                        tracing = 1;
+                        break;
+                default:
+                        return 0;
+                }
+        return 1;
 }
 
-void show_tracking(struct slabinfo *s)
+int slab_empty(struct slabinfo *s)
 {
-        printf("\n%s: Calls to allocate a slab object\n", s->name);
-        printf("---------------------------------------------------\n");
-        if (read_obj("alloc_calls"))
-                printf(buffer);
+        if (s->objects > 0)
+                return 0;
 
-        printf("%s: Calls to free a slab object\n", s->name);
-        printf("-----------------------------------------------\n");
-        if (read_obj("free_calls"))
-                printf(buffer);
+        /*
+         * We may still have slabs even if there are no objects. Shrinking will
+         * remove them.
+         */
+        if (s->slabs != 0)
+                set_obj(s, "shrink", 1);
 
+        return 1;
+}
+
+void slab_debug(struct slabinfo *s)
+{
+        if (sanity && !s->sanity_checks) {
+                set_obj(s, "sanity", 1);
+        }
+        if (!sanity && s->sanity_checks) {
+                if (slab_empty(s))
+                        set_obj(s, "sanity", 0);
+                else
+                        fprintf(stderr, "%s not empty cannot disable sanity checks\n", s->name);
+        }
+        if (redzone && !s->red_zone) {
+                if (slab_empty(s))
+                        set_obj(s, "red_zone", 1);
+                else
+                        fprintf(stderr, "%s not empty cannot enable redzoning\n", s->name);
+        }
+        if (!redzone && s->red_zone) {
+                if (slab_empty(s))
+                        set_obj(s, "red_zone", 0);
+                else
+                        fprintf(stderr, "%s not empty cannot disable redzoning\n", s->name);
+        }
+        if (poison && !s->poison) {
+                if (slab_empty(s))
+                        set_obj(s, "poison", 1);
+                else
+                        fprintf(stderr, "%s not empty cannot enable poisoning\n", s->name);
+        }
+        if (!poison && s->poison) {
+                if (slab_empty(s))
+                        set_obj(s, "poison", 0);
+                else
+                        fprintf(stderr, "%s not empty cannot disable poisoning\n", s->name);
+        }
+        if (tracking && !s->store_user) {
+                if (slab_empty(s))
+                        set_obj(s, "store_user", 1);
+                else
+                        fprintf(stderr, "%s not empty cannot enable tracking\n", s->name);
+        }
+        if (!tracking && s->store_user) {
+                if (slab_empty(s))
+                        set_obj(s, "store_user", 0);
+                else
+                        fprintf(stderr, "%s not empty cannot disable tracking\n", s->name);
+        }
+        if (tracing && !s->trace) {
+                if (slabs == 1)
+                        set_obj(s, "trace", 1);
+                else
+                        fprintf(stderr, "%s can only enable trace for one slab at a time\n", s->name);
+        }
+        if (!tracing && s->trace)
+                set_obj(s, "trace", 1);
 }
 
 void totals(void)
@@ -673,7 +926,7 @@ void link_slabs(void)
 
         for (a = aliasinfo; a < aliasinfo + aliases; a++) {
 
-                for(s = slabinfo; s < slabinfo + slabs; s++)
+                for (s = slabinfo; s < slabinfo + slabs; s++)
                         if (strcmp(a->ref, s->name) == 0) {
                                 a->slab = s;
                                 s->refs++;
@@ -704,7 +957,7 @@ void alias(void)
                                         continue;
                                 }
                         }
-                        printf("\n%-20s <- %s", a->slab->name, a->name);
+                        printf("\n%-12s <- %s", a->slab->name, a->name);
                         active = a->slab->name;
                 }
                 else
@@ -729,7 +982,12 @@ void rename_slabs(void)
 
                 a = find_one_alias(s);
 
-                s->name = a->name;
+                if (a)
+                        s->name = a->name;
+                else {
+                        s->name = "*";
+                        actual_slabs--;
+                }
         }
 }
 
@@ -748,11 +1006,14 @@ void read_slab_dir(void)
         char *t;
         int count;
 
+        if (chdir("/sys/slab"))
+                fatal("SYSFS support for SLUB not active\n");
+
         dir = opendir(".");
         while ((de = readdir(dir))) {
                 if (de->d_name[0] == '.' ||
-                                slab_mismatch(de->d_name))
-                        continue;
+                        (de->d_name[0] != ':' && slab_mismatch(de->d_name)))
+                                continue;
                 switch (de->d_type) {
                    case DT_LNK:
                         alias->name = strdup(de->d_name);
@@ -807,6 +1068,7 @@ void read_slab_dir(void)
         }
         closedir(dir);
         slabs = slab - slabinfo;
+        actual_slabs = slabs;
         aliases = alias - aliasinfo;
         if (slabs > MAX_SLABS)
                 fatal("Too many slabs\n");
@@ -825,34 +1087,37 @@ void output_slabs(void)
 
 
                 if (show_numa)
-                        slab_numa(slab);
-                else
-                if (show_track)
+                        slab_numa(slab, 0);
+                else if (show_track)
                         show_tracking(slab);
-                else
-                if (validate)
+                else if (validate)
                         slab_validate(slab);
-                else
-                if (shrink)
+                else if (shrink)
                         slab_shrink(slab);
-                else {
-                        if (show_slab)
-                                slabcache(slab);
-                }
+                else if (set_debug)
+                        slab_debug(slab);
+                else if (show_ops)
+                        ops(slab);
+                else if (show_slab)
+                        slabcache(slab);
         }
 }
 
 struct option opts[] = {
         { "aliases", 0, NULL, 'a' },
-        { "slabs", 0, NULL, 'l' },
-        { "numa", 0, NULL, 'n' },
-        { "zero", 0, NULL, 'z' },
-        { "help", 0, NULL, 'h' },
-        { "validate", 0, NULL, 'v' },
+        { "debug", 2, NULL, 'd' },
+        { "empty", 0, NULL, 'e' },
         { "first-alias", 0, NULL, 'f' },
+        { "help", 0, NULL, 'h' },
+        { "inverted", 0, NULL, 'i'},
+        { "numa", 0, NULL, 'n' },
+        { "ops", 0, NULL, 'o' },
+        { "report", 0, NULL, 'r' },
         { "shrink", 0, NULL, 's' },
+        { "slabs", 0, NULL, 'l' },
         { "track", 0, NULL, 't'},
-        { "inverted", 0, NULL, 'i'},
+        { "validate", 0, NULL, 'v' },
+        { "zero", 0, NULL, 'z' },
         { "1ref", 0, NULL, '1'},
         { NULL, 0, NULL, 0 }
 };
@@ -864,10 +1129,9 @@ int main(int argc, char *argv[])
         char *pattern_source;
 
         page_size = getpagesize();
-        if (chdir("/sys/slab"))
-                fatal("This kernel does not have SLUB support.\n");
 
-        while ((c = getopt_long(argc, argv, "afhil1npstvzTS", opts, NULL)) != -1)
+        while ((c = getopt_long(argc, argv, "ad::efhil1noprstvzTS",
+                                                opts, NULL)) != -1)
         switch(c) {
                 case '1':
                         show_single_ref = 1;
@@ -875,6 +1139,14 @@ int main(int argc, char *argv[])
                 case 'a':
                         show_alias = 1;
                         break;
+                case 'd':
+                        set_debug = 1;
+                        if (!debug_opt_scan(optarg))
+                                fatal("Invalid debug option '%s'\n", optarg);
+                        break;
+                case 'e':
+                        show_empty = 1;
+                        break;
                 case 'f':
                         show_first_alias = 1;
                         break;
@@ -887,6 +1159,12 @@ int main(int argc, char *argv[])
                 case 'n':
                         show_numa = 1;
                         break;
+                case 'o':
+                        show_ops = 1;
+                        break;
+                case 'r':
+                        show_report = 1;
+                        break;
                 case 's':
                         shrink = 1;
                         break;
@@ -914,8 +1192,8 @@ int main(int argc, char *argv[])
 
         }
 
-        if (!show_slab && !show_alias && !show_track
-                && !validate && !shrink)
+        if (!show_slab && !show_alias && !show_track && !show_report
+                && !validate && !shrink && !set_debug && !show_ops)
                         show_slab = 1;
 
         if (argc > optind)