How about moving the flags into the union?  A bit messy, but we don't
have to play games with __packed__.

diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 1210a8e41fad..f374d2f06255 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -68,16 +68,22 @@ struct mem_cgroup;
 #endif
 
 struct page {
-       unsigned long flags;            /* Atomic flags, some possibly
-                                        * updated asynchronously */
        /*
-        * Five words (20/40 bytes) are available in this union.
-        * WARNING: bit 0 of the first word is used for PageTail(). That
-        * means the other users of this union MUST NOT use the bit to
+        * This union is six words (24 / 48 bytes) in size.
+        * The first word is reserved for atomic flags, often updated
+        * asynchronously.  Use the PageFoo() macros to access it.  Some
+        * of the flags can be reused for your own purposes, but the
+        * word as a whole often contains other information and overwriting
+        * it will cause functions like page_zone() and page_node() to stop
+        * working correctly.
+        *
+        * Bit 0 of the second word is used for PageTail(). That
+        * means the other users of this union MUST leave the bit zero to
         * avoid collision and false-positive PageTail().
         */
        union {
                struct {        /* Page cache and anonymous pages */
+                       unsigned long flags;
                        /**
                         * @lru: Pageout list, eg. active_list protected by
                         * lruvec->lru_lock.  Sometimes used as a generic list
@@ -96,6 +102,8 @@ struct page {
                        unsigned long private;
                };
                struct {        /* page_pool used by netstack */
+                       unsigned long _pp_flags;
+                       unsigned long _pp_pad;
                        /**
                         * @dma_addr: might require a 64-bit value even on
                         * 32-bit architectures.
@@ -103,6 +111,7 @@ struct page {
                        dma_addr_t dma_addr;
                };
                struct {        /* slab, slob and slub */
+                       unsigned long _slab_flags;
                        union {
                                struct list_head slab_list;
                                struct {        /* Partial pages */
@@ -130,6 +139,7 @@ struct page {
                        };
                };
                struct {        /* Tail pages of compound page */
+                       unsigned long _tail1_flags;
                        unsigned long compound_head;    /* Bit zero is set */
 
                        /* First tail page only */
@@ -139,12 +149,14 @@ struct page {
                        unsigned int compound_nr; /* 1 << compound_order */
                };
                struct {        /* Second tail page of compound page */
+                       unsigned long _tail2_flags;
                        unsigned long _compound_pad_1;  /* compound_head */
                        atomic_t hpage_pinned_refcount;
                        /* For both global and memcg */
                        struct list_head deferred_list;
                };
                struct {        /* Page table pages */
+                       unsigned long _pt_flags;
                        unsigned long _pt_pad_1;        /* compound_head */
                        pgtable_t pmd_huge_pte; /* protected by page->ptl */
                        unsigned long _pt_pad_2;        /* mapping */
@@ -159,6 +171,7 @@ struct page {
 #endif
                };
                struct {        /* ZONE_DEVICE pages */
+                       unsigned long _zd_flags;
                        /** @pgmap: Points to the hosting device page map. */
                        struct dev_pagemap *pgmap;
                        void *zone_device_data;
@@ -174,8 +187,11 @@ struct page {
                         */
                };
 
-               /** @rcu_head: You can use this to free a page by RCU. */
-               struct rcu_head rcu_head;
+               struct {
+                       unsigned long _rcu_flags;
+                       /** @rcu_head: You can use this to free a page by RCU. 
*/
+                       struct rcu_head rcu_head;
+               };
        };
 
        union {         /* This union is 4 bytes in size. */

Reply via email to