Merge tag 'v3.12'

Linux 3.12

Conflicts:
	fs/exec.c

22 files changed, 649 insertions, 222 deletions

diff --git a/block/Kconfig b/block/Kconfig
index a7e40a7c8214..2429515c05c2 100644
--- a/block/Kconfig
+++ b/block/Kconfig
@@ -99,6 +99,17 @@ config BLK_DEV_THROTTLING
 
         See Documentation/cgroups/blkio-controller.txt for more information.
 
+config BLK_CMDLINE_PARSER
+        bool "Block device command line partition parser"
+        default n
+        ---help---
+        Enabling this option allows you to specify the partition layout from
+        the kernel boot args.  This is typically of use for embedded devices
+        which don't otherwise have any standardized method for listing the
+        partitions on a block device.
+
+        See Documentation/block/cmdline-partition.txt for more information.
+
 menu "Partition Types"
 
 source "block/partitions/Kconfig"
diff --git a/block/Makefile b/block/Makefile
index 39b76ba66ffd..671a83d063a5 100644
--- a/block/Makefile
+++ b/block/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_IOSCHED_CFQ)	+= cfq-iosched.o
 
 obj-$(CONFIG_BLOCK_COMPAT)      += compat_ioctl.o
 obj-$(CONFIG_BLK_DEV_INTEGRITY) += blk-integrity.o
+obj-$(CONFIG_BLK_CMDLINE_PARSER)        += cmdline-parser.o
diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index 290792a13e3c..4e491d9b5292 100644
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -235,8 +235,13 @@ static struct blkcg_gq *blkg_create(struct blkcg *blkcg,
         blkg->online = true;
         spin_unlock(&blkcg->lock);
 
-        if (!ret)
+        if (!ret) {
+                if (blkcg == &blkcg_root) {
+                        q->root_blkg = blkg;
+                        q->root_rl.blkg = blkg;
+                }
                 return blkg;
+        }
 
         /* @blkg failed fully initialized, use the usual release path */
         blkg_put(blkg);
@@ -335,6 +340,15 @@ static void blkg_destroy(struct blkcg_gq *blkg)
                 rcu_assign_pointer(blkcg->blkg_hint, NULL);
 
         /*
+         * If root blkg is destroyed.  Just clear the pointer since root_rl
+         * does not take reference on root blkg.
+         */
+        if (blkcg == &blkcg_root) {
+                blkg->q->root_blkg = NULL;
+                blkg->q->root_rl.blkg = NULL;
+        }
+
+        /*
          * Put the reference taken at the time of creation so that when all
          * queues are gone, group can be destroyed.
          */
@@ -360,13 +374,6 @@ static void blkg_destroy_all(struct request_queue *q)
                 blkg_destroy(blkg);
                 spin_unlock(&blkcg->lock);
         }
-
-        /*
-         * root blkg is destroyed.  Just clear the pointer since
-         * root_rl does not take reference on root blkg.
-         */
-        q->root_blkg = NULL;
-        q->root_rl.blkg = NULL;
 }
 
 /*
@@ -437,10 +444,10 @@ struct request_list *__blk_queue_next_rl(struct request_list *rl,
         return &blkg->rl;
 }
 
-static int blkcg_reset_stats(struct cgroup *cgroup, struct cftype *cftype,
-                             u64 val)
+static int blkcg_reset_stats(struct cgroup_subsys_state *css,
+                             struct cftype *cftype, u64 val)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkcg_gq *blkg;
         int i;
 
@@ -614,15 +621,13 @@ u64 blkg_stat_recursive_sum(struct blkg_policy_data *pd, int off)
 {
         struct blkcg_policy *pol = blkcg_policy[pd->plid];
         struct blkcg_gq *pos_blkg;
-        struct cgroup *pos_cgrp;
-        u64 sum;
+        struct cgroup_subsys_state *pos_css;
+        u64 sum = 0;
 
         lockdep_assert_held(pd->blkg->q->queue_lock);
 
-        sum = blkg_stat_read((void *)pd + off);
-
         rcu_read_lock();
-        blkg_for_each_descendant_pre(pos_blkg, pos_cgrp, pd_to_blkg(pd)) {
+        blkg_for_each_descendant_pre(pos_blkg, pos_css, pd_to_blkg(pd)) {
                 struct blkg_policy_data *pos_pd = blkg_to_pd(pos_blkg, pol);
                 struct blkg_stat *stat = (void *)pos_pd + off;
 
@@ -649,16 +654,14 @@ struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkg_policy_data *pd,
 {
         struct blkcg_policy *pol = blkcg_policy[pd->plid];
         struct blkcg_gq *pos_blkg;
-        struct cgroup *pos_cgrp;
-        struct blkg_rwstat sum;
+        struct cgroup_subsys_state *pos_css;
+        struct blkg_rwstat sum = { };
         int i;
 
         lockdep_assert_held(pd->blkg->q->queue_lock);
 
-        sum = blkg_rwstat_read((void *)pd + off);
-
         rcu_read_lock();
-        blkg_for_each_descendant_pre(pos_blkg, pos_cgrp, pd_to_blkg(pd)) {
+        blkg_for_each_descendant_pre(pos_blkg, pos_css, pd_to_blkg(pd)) {
                 struct blkg_policy_data *pos_pd = blkg_to_pd(pos_blkg, pol);
                 struct blkg_rwstat *rwstat = (void *)pos_pd + off;
                 struct blkg_rwstat tmp;
@@ -765,18 +768,18 @@ struct cftype blkcg_files[] = {
 
 /**
  * blkcg_css_offline - cgroup css_offline callback
- * @cgroup: cgroup of interest
+ * @css: css of interest
  *
- * This function is called when @cgroup is about to go away and responsible
- * for shooting down all blkgs associated with @cgroup.  blkgs should be
+ * This function is called when @css is about to go away and responsible
+ * for shooting down all blkgs associated with @css.  blkgs should be
  * removed while holding both q and blkcg locks.  As blkcg lock is nested
  * inside q lock, this function performs reverse double lock dancing.
  *
  * This is the blkcg counterpart of ioc_release_fn().
  */
-static void blkcg_css_offline(struct cgroup *cgroup)
+static void blkcg_css_offline(struct cgroup_subsys_state *css)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         spin_lock_irq(&blkcg->lock);
 
@@ -798,21 +801,21 @@ static void blkcg_css_offline(struct cgroup *cgroup)
         spin_unlock_irq(&blkcg->lock);
 }
 
-static void blkcg_css_free(struct cgroup *cgroup)
+static void blkcg_css_free(struct cgroup_subsys_state *css)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         if (blkcg != &blkcg_root)
                 kfree(blkcg);
 }
 
-static struct cgroup_subsys_state *blkcg_css_alloc(struct cgroup *cgroup)
+static struct cgroup_subsys_state *
+blkcg_css_alloc(struct cgroup_subsys_state *parent_css)
 {
         static atomic64_t id_seq = ATOMIC64_INIT(0);
         struct blkcg *blkcg;
-        struct cgroup *parent = cgroup->parent;
 
-        if (!parent) {
+        if (!parent_css) {
                 blkcg = &blkcg_root;
                 goto done;
         }
@@ -883,14 +886,15 @@ void blkcg_exit_queue(struct request_queue *q)
  * of the main cic data structures.  For now we allow a task to change
  * its cgroup only if it's the only owner of its ioc.
  */
-static int blkcg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
+static int blkcg_can_attach(struct cgroup_subsys_state *css,
+                            struct cgroup_taskset *tset)
 {
         struct task_struct *task;
         struct io_context *ioc;
         int ret = 0;
 
         /* task_lock() is needed to avoid races with exit_io_context() */
-        cgroup_taskset_for_each(task, cgrp, tset) {
+        cgroup_taskset_for_each(task, css, tset) {
                 task_lock(task);
                 ioc = task->io_context;
                 if (ioc && atomic_read(&ioc->nr_tasks) > 1)
@@ -973,8 +977,6 @@ int blkcg_activate_policy(struct request_queue *q,
                 ret = PTR_ERR(blkg);
                 goto out_unlock;
         }
-        q->root_blkg = blkg;
-        q->root_rl.blkg = blkg;
 
         list_for_each_entry(blkg, &q->blkg_list, q_node)
                 cnt++;
@@ -1127,7 +1129,7 @@ void blkcg_policy_unregister(struct blkcg_policy *pol)
 
         /* kill the intf files first */
         if (pol->cftypes)
-                cgroup_rm_cftypes(&blkio_subsys, pol->cftypes);
+                cgroup_rm_cftypes(pol->cftypes);
 
         /* unregister and update blkgs */
         blkcg_policy[pol->plid] = NULL;
diff --git a/block/blk-cgroup.h b/block/blk-cgroup.h
index 8056c03a3382..ae6969a7ffd4 100644
--- a/block/blk-cgroup.h
+++ b/block/blk-cgroup.h
@@ -179,22 +179,20 @@ int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
 void blkg_conf_finish(struct blkg_conf_ctx *ctx);
 
 
-static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup)
+static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
 {
-        return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
-                            struct blkcg, css);
+        return css ? container_of(css, struct blkcg, css) : NULL;
 }
 
 static inline struct blkcg *task_blkcg(struct task_struct *tsk)
 {
-        return container_of(task_subsys_state(tsk, blkio_subsys_id),
-                            struct blkcg, css);
+        return css_to_blkcg(task_css(tsk, blkio_subsys_id));
 }
 
 static inline struct blkcg *bio_blkcg(struct bio *bio)
 {
         if (bio && bio->bi_css)
-                return container_of(bio->bi_css, struct blkcg, css);
+                return css_to_blkcg(bio->bi_css);
         return task_blkcg(current);
 }
 
@@ -206,9 +204,7 @@ static inline struct blkcg *bio_blkcg(struct bio *bio)
  */
 static inline struct blkcg *blkcg_parent(struct blkcg *blkcg)
 {
-        struct cgroup *pcg = blkcg->css.cgroup->parent;
-
-        return pcg ? cgroup_to_blkcg(pcg) : NULL;
+        return css_to_blkcg(css_parent(&blkcg->css));
 }
 
 /**
@@ -288,32 +284,33 @@ struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg, struct request_queue *q,
 /**
  * blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants
  * @d_blkg: loop cursor pointing to the current descendant
- * @pos_cgrp: used for iteration
+ * @pos_css: used for iteration
  * @p_blkg: target blkg to walk descendants of
  *
  * Walk @c_blkg through the descendants of @p_blkg.  Must be used with RCU
  * read locked.  If called under either blkcg or queue lock, the iteration
  * is guaranteed to include all and only online blkgs.  The caller may
- * update @pos_cgrp by calling cgroup_rightmost_descendant() to skip
- * subtree.
+ * update @pos_css by calling css_rightmost_descendant() to skip subtree.
+ * @p_blkg is included in the iteration and the first node to be visited.
  */
-#define blkg_for_each_descendant_pre(d_blkg, pos_cgrp, p_blkg)          \
-        cgroup_for_each_descendant_pre((pos_cgrp), (p_blkg)->blkcg->css.cgroup) \
-                if (((d_blkg) = __blkg_lookup(cgroup_to_blkcg(pos_cgrp), \
+#define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg)           \
+        css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css)   \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
                                               (p_blkg)->q, false)))
 
 /**
  * blkg_for_each_descendant_post - post-order walk of a blkg's descendants
  * @d_blkg: loop cursor pointing to the current descendant
- * @pos_cgrp: used for iteration
+ * @pos_css: used for iteration
  * @p_blkg: target blkg to walk descendants of
  *
  * Similar to blkg_for_each_descendant_pre() but performs post-order
- * traversal instead.  Synchronization rules are the same.
+ * traversal instead.  Synchronization rules are the same.  @p_blkg is
+ * included in the iteration and the last node to be visited.
  */
-#define blkg_for_each_descendant_post(d_blkg, pos_cgrp, p_blkg)         \
-        cgroup_for_each_descendant_post((pos_cgrp), (p_blkg)->blkcg->css.cgroup) \
-                if (((d_blkg) = __blkg_lookup(cgroup_to_blkcg(pos_cgrp), \
+#define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg)          \
+        css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css)  \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
                                               (p_blkg)->q, false)))
 
 /**
@@ -576,7 +573,6 @@ static inline int blkcg_activate_policy(struct request_queue *q,
 static inline void blkcg_deactivate_policy(struct request_queue *q,
                                            const struct blkcg_policy *pol) { }
 
-static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup) { return NULL; }
 static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
 
 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
diff --git a/block/blk-core.c b/block/blk-core.c
index 93a18d1d3da8..0a00e4ecf87c 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1549,11 +1549,9 @@ get_rq:
         if (plug) {
                 /*
                  * If this is the first request added after a plug, fire
-                 * of a plug trace. If others have been added before, check
-                 * if we have multiple devices in this plug. If so, make a
-                 * note to sort the list before dispatch.
+                 * of a plug trace.
                  */
-                if (list_empty(&plug->list))
+                if (!request_count)
                         trace_block_plug(q);
                 else {
                         if (request_count >= BLK_MAX_REQUEST_COUNT) {
@@ -2318,6 +2316,12 @@ bool blk_update_request(struct request *req, int error, unsigned int nr_bytes)
                 case -ETIMEDOUT:
                         error_type = "timeout";
                         break;
+                case -ENOSPC:
+                        error_type = "critical space allocation";
+                        break;
+                case -ENODATA:
+                        error_type = "critical medium";
+                        break;
                 case -EIO:
                 default:
                         error_type = "I/O";
diff --git a/block/blk-exec.c b/block/blk-exec.c
index e70621396129..ae4f27d7944e 100644
--- a/block/blk-exec.c
+++ b/block/blk-exec.c
@@ -68,9 +68,9 @@ void blk_execute_rq_nowait(struct request_queue *q, struct gendisk *bd_disk,
         spin_lock_irq(q->queue_lock);
 
         if (unlikely(blk_queue_dying(q))) {
+                rq->cmd_flags |= REQ_QUIET; 
                 rq->errors = -ENXIO;
-                if (rq->end_io)
-                        rq->end_io(rq, rq->errors);
+                __blk_end_request_all(rq, rq->errors);
                 spin_unlock_irq(q->queue_lock);
                 return;
         }
diff --git a/block/blk-ioc.c b/block/blk-ioc.c
index 4464c823cff2..46cd7bd18b34 100644
--- a/block/blk-ioc.c
+++ b/block/blk-ioc.c
@@ -367,7 +367,7 @@ struct io_cq *ioc_create_icq(struct io_context *ioc, struct request_queue *q,
         if (!icq)
                 return NULL;
 
-        if (radix_tree_preload(gfp_mask) < 0) {
+        if (radix_tree_maybe_preload(gfp_mask) < 0) {
                 kmem_cache_free(et->icq_cache, icq);
                 return NULL;
         }
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index 5efc5a647183..3aa5b195f4dd 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -29,7 +29,7 @@ queue_var_store(unsigned long *var, const char *page, size_t count)
         int err;
         unsigned long v;
 
-        err = strict_strtoul(page, 10, &v);
+        err = kstrtoul(page, 10, &v);
         if (err || v > UINT_MAX)
                 return -EINVAL;
 
diff --git a/block/blk-throttle.c b/block/blk-throttle.c
index 08a32dfd3844..8331aba9426f 100644
--- a/block/blk-throttle.c
+++ b/block/blk-throttle.c
@@ -1293,10 +1293,10 @@ static u64 tg_prfill_cpu_rwstat(struct seq_file *sf,
         return __blkg_prfill_rwstat(sf, pd, &rwstat);
 }
 
-static int tg_print_cpu_rwstat(struct cgroup *cgrp, struct cftype *cft,
-                               struct seq_file *sf)
+static int tg_print_cpu_rwstat(struct cgroup_subsys_state *css,
+                               struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, tg_prfill_cpu_rwstat, &blkcg_policy_throtl,
                           cft->private, true);
@@ -1325,31 +1325,31 @@ static u64 tg_prfill_conf_uint(struct seq_file *sf, struct blkg_policy_data *pd,
         return __blkg_prfill_u64(sf, pd, v);
 }
 
-static int tg_print_conf_u64(struct cgroup *cgrp, struct cftype *cft,
-                             struct seq_file *sf)
+static int tg_print_conf_u64(struct cgroup_subsys_state *css,
+                             struct cftype *cft, struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp), tg_prfill_conf_u64,
+        blkcg_print_blkgs(sf, css_to_blkcg(css), tg_prfill_conf_u64,
                           &blkcg_policy_throtl, cft->private, false);
         return 0;
 }
 
-static int tg_print_conf_uint(struct cgroup *cgrp, struct cftype *cft,
-                              struct seq_file *sf)
+static int tg_print_conf_uint(struct cgroup_subsys_state *css,
+                              struct cftype *cft, struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp), tg_prfill_conf_uint,
+        blkcg_print_blkgs(sf, css_to_blkcg(css), tg_prfill_conf_uint,
                           &blkcg_policy_throtl, cft->private, false);
         return 0;
 }
 
-static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
-                       bool is_u64)
+static int tg_set_conf(struct cgroup_subsys_state *css, struct cftype *cft,
+                       const char *buf, bool is_u64)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkg_conf_ctx ctx;
         struct throtl_grp *tg;
         struct throtl_service_queue *sq;
         struct blkcg_gq *blkg;
-        struct cgroup *pos_cgrp;
+        struct cgroup_subsys_state *pos_css;
         int ret;
 
         ret = blkg_conf_prep(blkcg, &blkcg_policy_throtl, buf, &ctx);
@@ -1379,8 +1379,7 @@ static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
          * restrictions in the whole hierarchy and allows them to bypass
          * blk-throttle.
          */
-        tg_update_has_rules(tg);
-        blkg_for_each_descendant_pre(blkg, pos_cgrp, ctx.blkg)
+        blkg_for_each_descendant_pre(blkg, pos_css, ctx.blkg)
                 tg_update_has_rules(blkg_to_tg(blkg));
 
         /*
@@ -1403,16 +1402,16 @@ static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
         return 0;
 }
 
-static int tg_set_conf_u64(struct cgroup *cgrp, struct cftype *cft,
+static int tg_set_conf_u64(struct cgroup_subsys_state *css, struct cftype *cft,
                            const char *buf)
 {
-        return tg_set_conf(cgrp, cft, buf, true);
+        return tg_set_conf(css, cft, buf, true);
 }
 
-static int tg_set_conf_uint(struct cgroup *cgrp, struct cftype *cft,
+static int tg_set_conf_uint(struct cgroup_subsys_state *css, struct cftype *cft,
                             const char *buf)
 {
-        return tg_set_conf(cgrp, cft, buf, false);
+        return tg_set_conf(css, cft, buf, false);
 }
 
 static struct cftype throtl_files[] = {
@@ -1623,7 +1622,7 @@ void blk_throtl_drain(struct request_queue *q)
 {
         struct throtl_data *td = q->td;
         struct blkcg_gq *blkg;
-        struct cgroup *pos_cgrp;
+        struct cgroup_subsys_state *pos_css;
         struct bio *bio;
         int rw;
 
@@ -1636,11 +1635,9 @@ void blk_throtl_drain(struct request_queue *q)
          * better to walk service_queue tree directly but blkg walk is
          * easier.
          */
-        blkg_for_each_descendant_post(blkg, pos_cgrp, td->queue->root_blkg)
+        blkg_for_each_descendant_post(blkg, pos_css, td->queue->root_blkg)
                 tg_drain_bios(&blkg_to_tg(blkg)->service_queue);
 
-        tg_drain_bios(&td_root_tg(td)->service_queue);
-
         /* finally, transfer bios from top-level tg's into the td */
         tg_drain_bios(&td->service_queue);
 
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index d5bbdcfd0dab..434944cbd761 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -1607,12 +1607,11 @@ static u64 cfqg_prfill_weight_device(struct seq_file *sf,
         return __blkg_prfill_u64(sf, pd, cfqg->dev_weight);
 }
 
-static int cfqg_print_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                    struct seq_file *sf)
+static int cfqg_print_weight_device(struct cgroup_subsys_state *css,
+                                    struct cftype *cft, struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp),
-                          cfqg_prfill_weight_device, &blkcg_policy_cfq, 0,
-                          false);
+        blkcg_print_blkgs(sf, css_to_blkcg(css), cfqg_prfill_weight_device,
+                          &blkcg_policy_cfq, 0, false);
         return 0;
 }
 
@@ -1626,35 +1625,34 @@ static u64 cfqg_prfill_leaf_weight_device(struct seq_file *sf,
         return __blkg_prfill_u64(sf, pd, cfqg->dev_leaf_weight);
 }
 
-static int cfqg_print_leaf_weight_device(struct cgroup *cgrp,
+static int cfqg_print_leaf_weight_device(struct cgroup_subsys_state *css,
                                          struct cftype *cft,
                                          struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp),
-                          cfqg_prfill_leaf_weight_device, &blkcg_policy_cfq, 0,
-                          false);
+        blkcg_print_blkgs(sf, css_to_blkcg(css), cfqg_prfill_leaf_weight_device,
+                          &blkcg_policy_cfq, 0, false);
         return 0;
 }
 
-static int cfq_print_weight(struct cgroup *cgrp, struct cftype *cft,
+static int cfq_print_weight(struct cgroup_subsys_state *css, struct cftype *cft,
                             struct seq_file *sf)
 {
-        seq_printf(sf, "%u\n", cgroup_to_blkcg(cgrp)->cfq_weight);
+        seq_printf(sf, "%u\n", css_to_blkcg(css)->cfq_weight);
         return 0;
 }
 
-static int cfq_print_leaf_weight(struct cgroup *cgrp, struct cftype *cft,
-                                 struct seq_file *sf)
+static int cfq_print_leaf_weight(struct cgroup_subsys_state *css,
+                                 struct cftype *cft, struct seq_file *sf)
 {
-        seq_printf(sf, "%u\n",
-                   cgroup_to_blkcg(cgrp)->cfq_leaf_weight);
+        seq_printf(sf, "%u\n", css_to_blkcg(css)->cfq_leaf_weight);
         return 0;
 }
 
-static int __cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                    const char *buf, bool is_leaf_weight)
+static int __cfqg_set_weight_device(struct cgroup_subsys_state *css,
+                                    struct cftype *cft, const char *buf,
+                                    bool is_leaf_weight)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkg_conf_ctx ctx;
         struct cfq_group *cfqg;
         int ret;
@@ -1680,22 +1678,22 @@ static int __cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
         return ret;
 }
 
-static int cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                  const char *buf)
+static int cfqg_set_weight_device(struct cgroup_subsys_state *css,
+                                  struct cftype *cft, const char *buf)
 {
-        return __cfqg_set_weight_device(cgrp, cft, buf, false);
+        return __cfqg_set_weight_device(css, cft, buf, false);
 }
 
-static int cfqg_set_leaf_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                       const char *buf)
+static int cfqg_set_leaf_weight_device(struct cgroup_subsys_state *css,
+                                       struct cftype *cft, const char *buf)
 {
-        return __cfqg_set_weight_device(cgrp, cft, buf, true);
+        return __cfqg_set_weight_device(css, cft, buf, true);
 }
 
-static int __cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val,
-                            bool is_leaf_weight)
+static int __cfq_set_weight(struct cgroup_subsys_state *css, struct cftype *cft,
+                            u64 val, bool is_leaf_weight)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkcg_gq *blkg;
 
         if (val < CFQ_WEIGHT_MIN || val > CFQ_WEIGHT_MAX)
@@ -1727,30 +1725,32 @@ static int __cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val,
         return 0;
 }
 
-static int cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val)
+static int cfq_set_weight(struct cgroup_subsys_state *css, struct cftype *cft,
+                          u64 val)
 {
-        return __cfq_set_weight(cgrp, cft, val, false);
+        return __cfq_set_weight(css, cft, val, false);
 }
 
-static int cfq_set_leaf_weight(struct cgroup *cgrp, struct cftype *cft, u64 val)
+static int cfq_set_leaf_weight(struct cgroup_subsys_state *css,
+                               struct cftype *cft, u64 val)
 {
-        return __cfq_set_weight(cgrp, cft, val, true);
+        return __cfq_set_weight(css, cft, val, true);
 }
 
-static int cfqg_print_stat(struct cgroup *cgrp, struct cftype *cft,
+static int cfqg_print_stat(struct cgroup_subsys_state *css, struct cftype *cft,
                            struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, blkg_prfill_stat, &blkcg_policy_cfq,
                           cft->private, false);
         return 0;
 }
 
-static int cfqg_print_rwstat(struct cgroup *cgrp, struct cftype *cft,
-                             struct seq_file *sf)
+static int cfqg_print_rwstat(struct cgroup_subsys_state *css,
+                             struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, blkg_prfill_rwstat, &blkcg_policy_cfq,
                           cft->private, true);
@@ -1773,20 +1773,20 @@ static u64 cfqg_prfill_rwstat_recursive(struct seq_file *sf,
         return __blkg_prfill_rwstat(sf, pd, &sum);
 }
 
-static int cfqg_print_stat_recursive(struct cgroup *cgrp, struct cftype *cft,
-                                     struct seq_file *sf)
+static int cfqg_print_stat_recursive(struct cgroup_subsys_state *css,
+                                     struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, cfqg_prfill_stat_recursive,
                           &blkcg_policy_cfq, cft->private, false);
         return 0;
 }
 
-static int cfqg_print_rwstat_recursive(struct cgroup *cgrp, struct cftype *cft,
-                                       struct seq_file *sf)
+static int cfqg_print_rwstat_recursive(struct cgroup_subsys_state *css,
+                                       struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, cfqg_prfill_rwstat_recursive,
                           &blkcg_policy_cfq, cft->private, true);
@@ -1803,17 +1803,17 @@ static u64 cfqg_prfill_avg_queue_size(struct seq_file *sf,
 
         if (samples) {
                 v = blkg_stat_read(&cfqg->stats.avg_queue_size_sum);
-                do_div(v, samples);
+                v = div64_u64(v, samples);
         }
         __blkg_prfill_u64(sf, pd, v);
         return 0;
 }
 
 /* print avg_queue_size */
-static int cfqg_print_avg_queue_size(struct cgroup *cgrp, struct cftype *cft,
-                                     struct seq_file *sf)
+static int cfqg_print_avg_queue_size(struct cgroup_subsys_state *css,
+                                     struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, cfqg_prfill_avg_queue_size,
                           &blkcg_policy_cfq, 0, false);
@@ -4358,7 +4358,7 @@ static int cfq_init_queue(struct request_queue *q, struct elevator_type *e)
         if (!eq)
                 return -ENOMEM;
 
-        cfqd = kmalloc_node(sizeof(*cfqd), GFP_KERNEL | __GFP_ZERO, q->node);
+        cfqd = kzalloc_node(sizeof(*cfqd), GFP_KERNEL, q->node);
         if (!cfqd) {
                 kobject_put(&eq->kobj);
                 return -ENOMEM;
diff --git a/block/cmdline-parser.c b/block/cmdline-parser.c
new file mode 100644
index 000000000000..cc2637f8674e
--- /dev/null
+++ b/block/cmdline-parser.c
@@ -0,0 +1,250 @@
+/*
+ * Parse command line, get partition information
+ *
+ * Written by Cai Zhiyong <caizhiyong@huawei.com>
+ *
+ */
+#include <linux/buffer_head.h>
+#include <linux/module.h>
+#include <linux/cmdline-parser.h>
+
+static int parse_subpart(struct cmdline_subpart **subpart, char *partdef)
+{
+        int ret = 0;
+        struct cmdline_subpart *new_subpart;
+
+        *subpart = NULL;
+
+        new_subpart = kzalloc(sizeof(struct cmdline_subpart), GFP_KERNEL);
+        if (!new_subpart)
+                return -ENOMEM;
+
+        if (*partdef == '-') {
+                new_subpart->size = (sector_t)(~0ULL);
+                partdef++;
+        } else {
+                new_subpart->size = (sector_t)memparse(partdef, &partdef);
+                if (new_subpart->size < (sector_t)PAGE_SIZE) {
+                        pr_warn("cmdline partition size is invalid.");
+                        ret = -EINVAL;
+                        goto fail;
+                }
+        }
+
+        if (*partdef == '@') {
+                partdef++;
+                new_subpart->from = (sector_t)memparse(partdef, &partdef);
+        } else {
+                new_subpart->from = (sector_t)(~0ULL);
+        }
+
+        if (*partdef == '(') {
+                int length;
+                char *next = strchr(++partdef, ')');
+
+                if (!next) {
+                        pr_warn("cmdline partition format is invalid.");
+                        ret = -EINVAL;
+                        goto fail;
+                }
+
+                length = min_t(int, next - partdef,
+                               sizeof(new_subpart->name) - 1);
+                strncpy(new_subpart->name, partdef, length);
+                new_subpart->name[length] = '\0';
+
+                partdef = ++next;
+        } else
+                new_subpart->name[0] = '\0';
+
+        new_subpart->flags = 0;
+
+        if (!strncmp(partdef, "ro", 2)) {
+                new_subpart->flags |= PF_RDONLY;
+                partdef += 2;
+        }
+
+        if (!strncmp(partdef, "lk", 2)) {
+                new_subpart->flags |= PF_POWERUP_LOCK;
+                partdef += 2;
+        }
+
+        *subpart = new_subpart;
+        return 0;
+fail:
+        kfree(new_subpart);
+        return ret;
+}
+
+static void free_subpart(struct cmdline_parts *parts)
+{
+        struct cmdline_subpart *subpart;
+
+        while (parts->subpart) {
+                subpart = parts->subpart;
+                parts->subpart = subpart->next_subpart;
+                kfree(subpart);
+        }
+}
+
+static int parse_parts(struct cmdline_parts **parts, const char *bdevdef)
+{
+        int ret = -EINVAL;
+        char *next;
+        int length;
+        struct cmdline_subpart **next_subpart;
+        struct cmdline_parts *newparts;
+        char buf[BDEVNAME_SIZE + 32 + 4];
+
+        *parts = NULL;
+
+        newparts = kzalloc(sizeof(struct cmdline_parts), GFP_KERNEL);
+        if (!newparts)
+                return -ENOMEM;
+
+        next = strchr(bdevdef, ':');
+        if (!next) {
+                pr_warn("cmdline partition has no block device.");
+                goto fail;
+        }
+
+        length = min_t(int, next - bdevdef, sizeof(newparts->name) - 1);
+        strncpy(newparts->name, bdevdef, length);
+        newparts->name[length] = '\0';
+        newparts->nr_subparts = 0;
+
+        next_subpart = &newparts->subpart;
+
+        while (next && *(++next)) {
+                bdevdef = next;
+                next = strchr(bdevdef, ',');
+
+                length = (!next) ? (sizeof(buf) - 1) :
+                        min_t(int, next - bdevdef, sizeof(buf) - 1);
+
+                strncpy(buf, bdevdef, length);
+                buf[length] = '\0';
+
+                ret = parse_subpart(next_subpart, buf);
+                if (ret)
+                        goto fail;
+
+                newparts->nr_subparts++;
+                next_subpart = &(*next_subpart)->next_subpart;
+        }
+
+        if (!newparts->subpart) {
+                pr_warn("cmdline partition has no valid partition.");
+                ret = -EINVAL;
+                goto fail;
+        }
+
+        *parts = newparts;
+
+        return 0;
+fail:
+        free_subpart(newparts);
+        kfree(newparts);
+        return ret;
+}
+
+void cmdline_parts_free(struct cmdline_parts **parts)
+{
+        struct cmdline_parts *next_parts;
+
+        while (*parts) {
+                next_parts = (*parts)->next_parts;
+                free_subpart(*parts);
+                kfree(*parts);
+                *parts = next_parts;
+        }
+}
+
+int cmdline_parts_parse(struct cmdline_parts **parts, const char *cmdline)
+{
+        int ret;
+        char *buf;
+        char *pbuf;
+        char *next;
+        struct cmdline_parts **next_parts;
+
+        *parts = NULL;
+
+        next = pbuf = buf = kstrdup(cmdline, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        next_parts = parts;
+
+        while (next && *pbuf) {
+                next = strchr(pbuf, ';');
+                if (next)
+                        *next = '\0';
+
+                ret = parse_parts(next_parts, pbuf);
+                if (ret)
+                        goto fail;
+
+                if (next)
+                        pbuf = ++next;
+
+                next_parts = &(*next_parts)->next_parts;
+        }
+
+        if (!*parts) {
+                pr_warn("cmdline partition has no valid partition.");
+                ret = -EINVAL;
+                goto fail;
+        }
+
+        ret = 0;
+done:
+        kfree(buf);
+        return ret;
+
+fail:
+        cmdline_parts_free(parts);
+        goto done;
+}
+
+struct cmdline_parts *cmdline_parts_find(struct cmdline_parts *parts,
+                                         const char *bdev)
+{
+        while (parts && strncmp(bdev, parts->name, sizeof(parts->name)))
+                parts = parts->next_parts;
+        return parts;
+}
+
+/*
+ *  add_part()
+ *    0 success.
+ *    1 can not add so many partitions.
+ */
+void cmdline_parts_set(struct cmdline_parts *parts, sector_t disk_size,
+                       int slot,
+                       int (*add_part)(int, struct cmdline_subpart *, void *),
+                       void *param)
+
+{
+        sector_t from = 0;
+        struct cmdline_subpart *subpart;
+
+        for (subpart = parts->subpart; subpart;
+             subpart = subpart->next_subpart, slot++) {
+                if (subpart->from == (sector_t)(~0ULL))
+                        subpart->from = from;
+                else
+                        from = subpart->from;
+
+                if (from >= disk_size)
+                        break;
+
+                if (subpart->size > (disk_size - from))
+                        subpart->size = disk_size - from;
+
+                from += subpart->size;
+
+                if (add_part(slot, subpart, param))
+                        break;
+        }
+}
diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index 7e5d474dc6ba..fbd5a67cb773 100644
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -70,7 +70,7 @@ static int compat_hdio_getgeo(struct gendisk *disk, struct block_device *bdev,
                 return ret;
 
         ret = copy_to_user(ugeo, &geo, 4);
-        ret |= __put_user(geo.start, &ugeo->start);
+        ret |= put_user(geo.start, &ugeo->start);
         if (ret)
                 ret = -EFAULT;
 
diff --git a/block/deadline-iosched.c b/block/deadline-iosched.c
index 20614a332362..9ef66406c625 100644
--- a/block/deadline-iosched.c
+++ b/block/deadline-iosched.c
@@ -346,7 +346,7 @@ static int deadline_init_queue(struct request_queue *q, struct elevator_type *e)
         if (!eq)
                 return -ENOMEM;
 
-        dd = kmalloc_node(sizeof(*dd), GFP_KERNEL | __GFP_ZERO, q->node);
+        dd = kzalloc_node(sizeof(*dd), GFP_KERNEL, q->node);
         if (!dd) {
                 kobject_put(&eq->kobj);
                 return -ENOMEM;
diff --git a/block/elevator.c b/block/elevator.c
index 668394d18588..2bcbd8cc14d4 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -155,7 +155,7 @@ struct elevator_queue *elevator_alloc(struct request_queue *q,
 {
         struct elevator_queue *eq;
 
-        eq = kmalloc_node(sizeof(*eq), GFP_KERNEL | __GFP_ZERO, q->node);
+        eq = kzalloc_node(sizeof(*eq), GFP_KERNEL, q->node);
         if (unlikely(!eq))
                 goto err;
 
diff --git a/block/genhd.c b/block/genhd.c
index dadf42b454a3..791f41943132 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -1252,8 +1252,7 @@ struct gendisk *alloc_disk_node(int minors, int node_id)
 {
         struct gendisk *disk;
 
-        disk = kmalloc_node(sizeof(struct gendisk),
-                                GFP_KERNEL | __GFP_ZERO, node_id);
+        disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
         if (disk) {
                 if (!init_part_stats(&disk->part0)) {
                         kfree(disk);
diff --git a/block/partitions/Kconfig b/block/partitions/Kconfig
index 4cebb2f0d2f4..9b29a996c311 100644
--- a/block/partitions/Kconfig
+++ b/block/partitions/Kconfig
@@ -260,3 +260,10 @@ config SYSV68_PARTITION
           partition table format used by Motorola Delta machines (using
           sysv68).
           Otherwise, say N.
+
+config CMDLINE_PARTITION
+        bool "Command line partition support" if PARTITION_ADVANCED
+        select BLK_CMDLINE_PARSER
+        help
+          Say Y here if you want to read the partition table from bootargs.
+          The format for the command line is just like mtdparts.
diff --git a/block/partitions/Makefile b/block/partitions/Makefile
index 2be4d7ba4e3a..37a95270503c 100644
--- a/block/partitions/Makefile
+++ b/block/partitions/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_ACORN_PARTITION) += acorn.o
 obj-$(CONFIG_AMIGA_PARTITION) += amiga.o
 obj-$(CONFIG_ATARI_PARTITION) += atari.o
 obj-$(CONFIG_AIX_PARTITION) += aix.o
+obj-$(CONFIG_CMDLINE_PARTITION) += cmdline.o
 obj-$(CONFIG_MAC_PARTITION) += mac.o
 obj-$(CONFIG_LDM_PARTITION) += ldm.o
 obj-$(CONFIG_MSDOS_PARTITION) += msdos.o
diff --git a/block/partitions/check.c b/block/partitions/check.c
index 19ba207ea7d1..9ac1df74f699 100644
--- a/block/partitions/check.c
+++ b/block/partitions/check.c
@@ -34,6 +34,7 @@
 #include "efi.h"
 #include "karma.h"
 #include "sysv68.h"
+#include "cmdline.h"
 
 int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/
 
@@ -65,6 +66,9 @@ static int (*check_part[])(struct parsed_partitions *) = {
         adfspart_check_ADFS,
 #endif
 
+#ifdef CONFIG_CMDLINE_PARTITION
+        cmdline_partition,
+#endif
 #ifdef CONFIG_EFI_PARTITION
         efi_partition,          /* this must come before msdos */
 #endif
diff --git a/block/partitions/cmdline.c b/block/partitions/cmdline.c
new file mode 100644
index 000000000000..5141b563adf1
--- /dev/null
+++ b/block/partitions/cmdline.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2013 HUAWEI
+ * Author: Cai Zhiyong <caizhiyong@huawei.com>
+ *
+ * Read block device partition table from the command line.
+ * Typically used for fixed block (eMMC) embedded devices.
+ * It has no MBR, so saves storage space. Bootloader can be easily accessed
+ * by absolute address of data on the block device.
+ * Users can easily change the partition.
+ *
+ * The format for the command line is just like mtdparts.
+ *
+ * For further information, see "Documentation/block/cmdline-partition.txt"
+ *
+ */
+
+#include <linux/cmdline-parser.h>
+
+#include "check.h"
+#include "cmdline.h"
+
+static char *cmdline;
+static struct cmdline_parts *bdev_parts;
+
+static int add_part(int slot, struct cmdline_subpart *subpart, void *param)
+{
+        int label_min;
+        struct partition_meta_info *info;
+        char tmp[sizeof(info->volname) + 4];
+        struct parsed_partitions *state = (struct parsed_partitions *)param;
+
+        if (slot >= state->limit)
+                return 1;
+
+        put_partition(state, slot, subpart->from >> 9,
+                      subpart->size >> 9);
+
+        info = &state->parts[slot].info;
+
+        label_min = min_t(int, sizeof(info->volname) - 1,
+                          sizeof(subpart->name));
+        strncpy(info->volname, subpart->name, label_min);
+        info->volname[label_min] = '\0';
+
+        snprintf(tmp, sizeof(tmp), "(%s)", info->volname);
+        strlcat(state->pp_buf, tmp, PAGE_SIZE);
+
+        state->parts[slot].has_info = true;
+
+        return 0;
+}
+
+static int __init cmdline_parts_setup(char *s)
+{
+        cmdline = s;
+        return 1;
+}
+__setup("blkdevparts=", cmdline_parts_setup);
+
+/*
+ * Purpose: allocate cmdline partitions.
+ * Returns:
+ * -1 if unable to read the partition table
+ *  0 if this isn't our partition table
+ *  1 if successful
+ */
+int cmdline_partition(struct parsed_partitions *state)
+{
+        sector_t disk_size;
+        char bdev[BDEVNAME_SIZE];
+        struct cmdline_parts *parts;
+
+        if (cmdline) {
+                if (bdev_parts)
+                        cmdline_parts_free(&bdev_parts);
+
+                if (cmdline_parts_parse(&bdev_parts, cmdline)) {
+                        cmdline = NULL;
+                        return -1;
+                }
+                cmdline = NULL;
+        }
+
+        if (!bdev_parts)
+                return 0;
+
+        bdevname(state->bdev, bdev);
+        parts = cmdline_parts_find(bdev_parts, bdev);
+        if (!parts)
+                return 0;
+
+        disk_size = get_capacity(state->bdev->bd_disk) << 9;
+
+        cmdline_parts_set(parts, disk_size, 1, add_part, (void *)state);
+
+        strlcat(state->pp_buf, "\n", PAGE_SIZE);
+
+        return 1;
+}
diff --git a/block/partitions/cmdline.h b/block/partitions/cmdline.h
new file mode 100644
index 000000000000..26e0f8da1414
--- /dev/null
+++ b/block/partitions/cmdline.h
@@ -0,0 +1,2 @@
+
+int cmdline_partition(struct parsed_partitions *state);
diff --git a/block/partitions/efi.c b/block/partitions/efi.c
index c85fc895ecdb..a8287b49d062 100644
--- a/block/partitions/efi.c
+++ b/block/partitions/efi.c
@@ -25,6 +25,9 @@
  * TODO:
  *
  * Changelog:
+ * Mon August 5th, 2013 Davidlohr Bueso <davidlohr@hp.com>
+ * - detect hybrid MBRs, tighter pMBR checking & cleanups.
+ *
  * Mon Nov 09 2004 Matt Domsch <Matt_Domsch@dell.com>
  * - test for valid PMBR and valid PGPT before ever reading
  *   AGPT, allow override with 'gpt' kernel command line option.
@@ -149,34 +152,89 @@ static u64 last_lba(struct block_device *bdev)
                        bdev_logical_block_size(bdev)) - 1ULL;
 }
 
-static inline int
-pmbr_part_valid(struct partition *part)
+static inline int pmbr_part_valid(gpt_mbr_record *part)
 {
-        if (part->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT &&
-            le32_to_cpu(part->start_sect) == 1UL)
-                return 1;
-        return 0;
+        if (part->os_type != EFI_PMBR_OSTYPE_EFI_GPT)
+                goto invalid;
+
+        /* set to 0x00000001 (i.e., the LBA of the GPT Partition Header) */
+        if (le32_to_cpu(part->starting_lba) != GPT_PRIMARY_PARTITION_TABLE_LBA)
+                goto invalid;
+
+        return GPT_MBR_PROTECTIVE;
+invalid:
+        return 0;
 }
 
 /**
  * is_pmbr_valid(): test Protective MBR for validity
  * @mbr: pointer to a legacy mbr structure
+ * @total_sectors: amount of sectors in the device
  *
- * Description: Returns 1 if PMBR is valid, 0 otherwise.
- * Validity depends on two things:
+ * Description: Checks for a valid protective or hybrid
+ * master boot record (MBR). The validity of a pMBR depends
+ * on all of the following properties:
  *  1) MSDOS signature is in the last two bytes of the MBR
  *  2) One partition of type 0xEE is found
+ *
+ * In addition, a hybrid MBR will have up to three additional
+ * primary partitions, which point to the same space that's
+ * marked out by up to three GPT partitions.
+ *
+ * Returns 0 upon invalid MBR, or GPT_MBR_PROTECTIVE or
+ * GPT_MBR_HYBRID depending on the device layout.
  */
-static int
-is_pmbr_valid(legacy_mbr *mbr)
+static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors)
 {
-        int i;
+        uint32_t sz = 0;
+        int i, part = 0, ret = 0; /* invalid by default */
+
         if (!mbr || le16_to_cpu(mbr->signature) != MSDOS_MBR_SIGNATURE)
-                return 0;
+                goto done;
+
+        for (i = 0; i < 4; i++) {
+                ret = pmbr_part_valid(&mbr->partition_record[i]);
+                if (ret == GPT_MBR_PROTECTIVE) {
+                        part = i;
+                        /*
+                         * Ok, we at least know that there's a protective MBR,
+                         * now check if there are other partition types for
+                         * hybrid MBR.
+                         */
+                        goto check_hybrid;
+                }
+        }
+
+        if (ret != GPT_MBR_PROTECTIVE)
+                goto done;
+check_hybrid:
         for (i = 0; i < 4; i++)
-                if (pmbr_part_valid(&mbr->partition_record[i]))
-                        return 1;
-        return 0;
+                if ((mbr->partition_record[i].os_type !=
+                        EFI_PMBR_OSTYPE_EFI_GPT) &&
+                    (mbr->partition_record[i].os_type != 0x00))
+                        ret = GPT_MBR_HYBRID;
+
+        /*
+         * Protective MBRs take up the lesser of the whole disk
+         * or 2 TiB (32bit LBA), ignoring the rest of the disk.
+         * Some partitioning programs, nonetheless, choose to set
+         * the size to the maximum 32-bit limitation, disregarding
+         * the disk size.
+         *
+         * Hybrid MBRs do not necessarily comply with this.
+         *
+         * Consider a bad value here to be a warning to support dd'ing
+         * an image from a smaller disk to a larger disk.
+         */
+        if (ret == GPT_MBR_PROTECTIVE) {
+                sz = le32_to_cpu(mbr->partition_record[part].size_in_lba);
+                if (sz != (uint32_t) total_sectors - 1 && sz != 0xFFFFFFFF)
+                        pr_debug("GPT: mbr size in lba (%u) different than whole disk (%u).\n",
+                                 sz, min_t(uint32_t,
+                                           total_sectors - 1, 0xFFFFFFFF));
+        }
+done:
+        return ret;
 }
 
 /**
@@ -243,8 +301,7 @@ static gpt_entry *alloc_read_gpt_entries(struct parsed_partitions *state,
                 return NULL;
 
         if (read_lba(state, le64_to_cpu(gpt->partition_entry_lba),
-                     (u8 *) pte,
-                     count) < count) {
+                        (u8 *) pte, count) < count) {
                 kfree(pte);
                 pte=NULL;
                 return NULL;
@@ -364,7 +421,12 @@ static int is_gpt_valid(struct parsed_partitions *state, u64 lba,
                          (unsigned long long)lastlba);
                 goto fail;
         }
-
+        if (le64_to_cpu((*gpt)->last_usable_lba) < le64_to_cpu((*gpt)->first_usable_lba)) {
+                pr_debug("GPT: last_usable_lba incorrect: %lld > %lld\n",
+                         (unsigned long long)le64_to_cpu((*gpt)->last_usable_lba),
+                         (unsigned long long)le64_to_cpu((*gpt)->first_usable_lba));
+                goto fail;
+        }
         /* Check that sizeof_partition_entry has the correct value */
         if (le32_to_cpu((*gpt)->sizeof_partition_entry) != sizeof(gpt_entry)) {
                 pr_debug("GUID Partitition Entry Size check failed.\n");
@@ -429,44 +491,42 @@ compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
         if (!pgpt || !agpt)
                 return;
         if (le64_to_cpu(pgpt->my_lba) != le64_to_cpu(agpt->alternate_lba)) {
-                printk(KERN_WARNING
-                       "GPT:Primary header LBA != Alt. header alternate_lba\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
+                pr_warn("GPT:Primary header LBA != Alt. header alternate_lba\n");
+                pr_warn("GPT:%lld != %lld\n",
                        (unsigned long long)le64_to_cpu(pgpt->my_lba),
                        (unsigned long long)le64_to_cpu(agpt->alternate_lba));
                 error_found++;
         }
         if (le64_to_cpu(pgpt->alternate_lba) != le64_to_cpu(agpt->my_lba)) {
-                printk(KERN_WARNING
-                       "GPT:Primary header alternate_lba != Alt. header my_lba\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
+                pr_warn("GPT:Primary header alternate_lba != Alt. header my_lba\n");
+                pr_warn("GPT:%lld != %lld\n",
                        (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
                        (unsigned long long)le64_to_cpu(agpt->my_lba));
                 error_found++;
         }
         if (le64_to_cpu(pgpt->first_usable_lba) !=
             le64_to_cpu(agpt->first_usable_lba)) {
-                printk(KERN_WARNING "GPT:first_usable_lbas don't match.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
+                pr_warn("GPT:first_usable_lbas don't match.\n");
+                pr_warn("GPT:%lld != %lld\n",
                        (unsigned long long)le64_to_cpu(pgpt->first_usable_lba),
                        (unsigned long long)le64_to_cpu(agpt->first_usable_lba));
                 error_found++;
         }
         if (le64_to_cpu(pgpt->last_usable_lba) !=
             le64_to_cpu(agpt->last_usable_lba)) {
-                printk(KERN_WARNING "GPT:last_usable_lbas don't match.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
+                pr_warn("GPT:last_usable_lbas don't match.\n");
+                pr_warn("GPT:%lld != %lld\n",
                        (unsigned long long)le64_to_cpu(pgpt->last_usable_lba),
                        (unsigned long long)le64_to_cpu(agpt->last_usable_lba));
                 error_found++;
         }
         if (efi_guidcmp(pgpt->disk_guid, agpt->disk_guid)) {
-                printk(KERN_WARNING "GPT:disk_guids don't match.\n");
+                pr_warn("GPT:disk_guids don't match.\n");
                 error_found++;
         }
         if (le32_to_cpu(pgpt->num_partition_entries) !=
             le32_to_cpu(agpt->num_partition_entries)) {
-                printk(KERN_WARNING "GPT:num_partition_entries don't match: "
+                pr_warn("GPT:num_partition_entries don't match: "
                        "0x%x != 0x%x\n",
                        le32_to_cpu(pgpt->num_partition_entries),
                        le32_to_cpu(agpt->num_partition_entries));
@@ -474,8 +534,7 @@ compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
         }
         if (le32_to_cpu(pgpt->sizeof_partition_entry) !=
             le32_to_cpu(agpt->sizeof_partition_entry)) {
-                printk(KERN_WARNING
-                       "GPT:sizeof_partition_entry values don't match: "
+                pr_warn("GPT:sizeof_partition_entry values don't match: "
                        "0x%x != 0x%x\n",
                        le32_to_cpu(pgpt->sizeof_partition_entry),
                        le32_to_cpu(agpt->sizeof_partition_entry));
@@ -483,34 +542,30 @@ compare_gpts(gpt_header *pgpt, gpt_header *agpt, u64 lastlba)
         }
         if (le32_to_cpu(pgpt->partition_entry_array_crc32) !=
             le32_to_cpu(agpt->partition_entry_array_crc32)) {
-                printk(KERN_WARNING
-                       "GPT:partition_entry_array_crc32 values don't match: "
+                pr_warn("GPT:partition_entry_array_crc32 values don't match: "
                        "0x%x != 0x%x\n",
                        le32_to_cpu(pgpt->partition_entry_array_crc32),
                        le32_to_cpu(agpt->partition_entry_array_crc32));
                 error_found++;
         }
         if (le64_to_cpu(pgpt->alternate_lba) != lastlba) {
-                printk(KERN_WARNING
-                       "GPT:Primary header thinks Alt. header is not at the end of the disk.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
+                pr_warn("GPT:Primary header thinks Alt. header is not at the end of the disk.\n");
+                pr_warn("GPT:%lld != %lld\n",
                         (unsigned long long)le64_to_cpu(pgpt->alternate_lba),
                         (unsigned long long)lastlba);
                 error_found++;
         }
 
         if (le64_to_cpu(agpt->my_lba) != lastlba) {
-                printk(KERN_WARNING
-                       "GPT:Alternate GPT header not at the end of the disk.\n");
-                printk(KERN_WARNING "GPT:%lld != %lld\n",
+                pr_warn("GPT:Alternate GPT header not at the end of the disk.\n");
+                pr_warn("GPT:%lld != %lld\n",
                         (unsigned long long)le64_to_cpu(agpt->my_lba),
                         (unsigned long long)lastlba);
                 error_found++;
         }
 
         if (error_found)
-                printk(KERN_WARNING
-                       "GPT: Use GNU Parted to correct GPT errors.\n");
+                pr_warn("GPT: Use GNU Parted to correct GPT errors.\n");
         return;
 }
 
@@ -536,6 +591,7 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
         gpt_header *pgpt = NULL, *agpt = NULL;
         gpt_entry *pptes = NULL, *aptes = NULL;
         legacy_mbr *legacymbr;
+        sector_t total_sectors = i_size_read(state->bdev->bd_inode) >> 9;
         u64 lastlba;
 
         if (!ptes)
@@ -543,17 +599,22 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
 
         lastlba = last_lba(state->bdev);
         if (!force_gpt) {
-                /* This will be added to the EFI Spec. per Intel after v1.02. */
-                legacymbr = kzalloc(sizeof (*legacymbr), GFP_KERNEL);
-                if (legacymbr) {
-                        read_lba(state, 0, (u8 *) legacymbr,
-                                 sizeof (*legacymbr));
-                        good_pmbr = is_pmbr_valid(legacymbr);
-                        kfree(legacymbr);
-                }
-                if (!good_pmbr)
-                        goto fail;
-        }
+                /* This will be added to the EFI Spec. per Intel after v1.02. */
+                legacymbr = kzalloc(sizeof(*legacymbr), GFP_KERNEL);
+                if (!legacymbr)
+                        goto fail;
+
+                read_lba(state, 0, (u8 *)legacymbr, sizeof(*legacymbr));
+                good_pmbr = is_pmbr_valid(legacymbr, total_sectors);
+                kfree(legacymbr);
+
+                if (!good_pmbr)
+                        goto fail;
+
+                pr_debug("Device has a %s MBR\n",
+                         good_pmbr == GPT_MBR_PROTECTIVE ?
+                                                "protective" : "hybrid");
+        }
 
         good_pgpt = is_gpt_valid(state, GPT_PRIMARY_PARTITION_TABLE_LBA,
                                  &pgpt, &pptes);
@@ -576,11 +637,8 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
                 *ptes = pptes;
                 kfree(agpt);
                 kfree(aptes);
-                if (!good_agpt) {
-                        printk(KERN_WARNING 
-                               "Alternate GPT is invalid, "
-                               "using primary GPT.\n");
-                }
+                if (!good_agpt)
+                        pr_warn("Alternate GPT is invalid, using primary GPT.\n");
                 return 1;
         }
         else if (good_agpt) {
@@ -588,8 +646,7 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,
                 *ptes = aptes;
                 kfree(pgpt);
                 kfree(pptes);
-                printk(KERN_WARNING 
-                       "Primary GPT is invalid, using alternate GPT.\n");
+                pr_warn("Primary GPT is invalid, using alternate GPT.\n");
                 return 1;
         }
 
@@ -651,8 +708,7 @@ int efi_partition(struct parsed_partitions *state)
                 put_partition(state, i+1, start * ssz, size * ssz);
 
                 /* If this is a RAID volume, tell md */
-                if (!efi_guidcmp(ptes[i].partition_type_guid,
-                                 PARTITION_LINUX_RAID_GUID))
+                if (!efi_guidcmp(ptes[i].partition_type_guid, PARTITION_LINUX_RAID_GUID))
                         state->parts[i + 1].flags = ADDPART_FLAG_RAID;
 
                 info = &state->parts[i + 1].info;
diff --git a/block/partitions/efi.h b/block/partitions/efi.h
index b69ab729558f..4efcafba7e64 100644
--- a/block/partitions/efi.h
+++ b/block/partitions/efi.h
@@ -37,6 +37,9 @@
 #define EFI_PMBR_OSTYPE_EFI 0xEF
 #define EFI_PMBR_OSTYPE_EFI_GPT 0xEE
 
+#define GPT_MBR_PROTECTIVE  1
+#define GPT_MBR_HYBRID      2
+
 #define GPT_HEADER_SIGNATURE 0x5452415020494645ULL
 #define GPT_HEADER_REVISION_V1 0x00010000
 #define GPT_PRIMARY_PARTITION_TABLE_LBA 1
@@ -101,11 +104,25 @@ typedef struct _gpt_entry {
         efi_char16_t partition_name[72 / sizeof (efi_char16_t)];
 } __attribute__ ((packed)) gpt_entry;
 
+typedef struct _gpt_mbr_record {
+        u8      boot_indicator; /* unused by EFI, set to 0x80 for bootable */
+        u8      start_head;     /* unused by EFI, pt start in CHS */
+        u8      start_sector;   /* unused by EFI, pt start in CHS */
+        u8      start_track;
+        u8      os_type;        /* EFI and legacy non-EFI OS types */
+        u8      end_head;       /* unused by EFI, pt end in CHS */
+        u8      end_sector;     /* unused by EFI, pt end in CHS */
+        u8      end_track;      /* unused by EFI, pt end in CHS */
+        __le32  starting_lba;   /* used by EFI - start addr of the on disk pt */
+        __le32  size_in_lba;    /* used by EFI - size of pt in LBA */
+} __packed gpt_mbr_record;
+
+
 typedef struct _legacy_mbr {
         u8 boot_code[440];
         __le32 unique_mbr_signature;
         __le16 unknown;
-        struct partition partition_record[4];
+        gpt_mbr_record partition_record[4];
         __le16 signature;
 } __attribute__ ((packed)) legacy_mbr;
 
@@ -113,22 +130,3 @@ typedef struct _legacy_mbr {
 extern int efi_partition(struct parsed_partitions *state);
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * --------------------------------------------------------------------------
- * Local variables:
- * c-indent-level: 4 
- * c-brace-imaginary-offset: 0
- * c-brace-offset: -4
- * c-argdecl-indent: 4
- * c-label-offset: -4
- * c-continued-statement-offset: 4
- * c-continued-brace-offset: 0
- * indent-tabs-mode: nil
- * tab-width: 8
- * End:
- */