Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

[linux-2.6-microblaze.git] / include / linux / hugetlb.h

diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index b5807f2..cccd1aa 100644 (file)
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -37,7 +37,7 @@ struct hugepage_subpool {
        struct hstate *hstate;
        long min_hpages;        /* Minimum huge pages or -1 if no minimum. */
        long rsv_hpages;        /* Pages reserved against global pool to */
-                               /* sasitfy minimum size. */
+                               /* satisfy minimum size. */
 };
 
 struct resv_map {
@@ -139,7 +139,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm, pte_t *dst_pte,
                                unsigned long dst_addr,
                                unsigned long src_addr,
                                struct page **pagep);
-int hugetlb_reserve_pages(struct inode *inode, long from, long to,
+bool hugetlb_reserve_pages(struct inode *inode, long from, long to,
                                                struct vm_area_struct *vma,
                                                vm_flags_t vm_flags);
 long hugetlb_unreserve_pages(struct inode *inode, long start, long end,
@@ -472,6 +472,84 @@ unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
                                        unsigned long flags);
 #endif /* HAVE_ARCH_HUGETLB_UNMAPPED_AREA */
 
+/*
+ * huegtlb page specific state flags.  These flags are located in page.private
+ * of the hugetlb head page.  Functions created via the below macros should be
+ * used to manipulate these flags.
+ *
+ * HPG_restore_reserve - Set when a hugetlb page consumes a reservation at
+ *     allocation time.  Cleared when page is fully instantiated.  Free
+ *     routine checks flag to restore a reservation on error paths.
+ *     Synchronization:  Examined or modified by code that knows it has
+ *     the only reference to page.  i.e. After allocation but before use
+ *     or when the page is being freed.
+ * HPG_migratable  - Set after a newly allocated page is added to the page
+ *     cache and/or page tables.  Indicates the page is a candidate for
+ *     migration.
+ *     Synchronization:  Initially set after new page allocation with no
+ *     locking.  When examined and modified during migration processing
+ *     (isolate, migrate, putback) the hugetlb_lock is held.
+ * HPG_temporary - - Set on a page that is temporarily allocated from the buddy
+ *     allocator.  Typically used for migration target pages when no pages
+ *     are available in the pool.  The hugetlb free page path will
+ *     immediately free pages with this flag set to the buddy allocator.
+ *     Synchronization: Can be set after huge page allocation from buddy when
+ *     code knows it has only reference.  All other examinations and
+ *     modifications require hugetlb_lock.
+ * HPG_freed - Set when page is on the free lists.
+ *     Synchronization: hugetlb_lock held for examination and modification.
+ */
+enum hugetlb_page_flags {
+       HPG_restore_reserve = 0,
+       HPG_migratable,
+       HPG_temporary,
+       HPG_freed,
+       __NR_HPAGEFLAGS,
+};
+
+/*
+ * Macros to create test, set and clear function definitions for
+ * hugetlb specific page flags.
+ */
+#ifdef CONFIG_HUGETLB_PAGE
+#define TESTHPAGEFLAG(uname, flname)                           \
+static inline int HPage##uname(struct page *page)              \
+       { return test_bit(HPG_##flname, &(page->private)); }
+
+#define SETHPAGEFLAG(uname, flname)                            \
+static inline void SetHPage##uname(struct page *page)          \
+       { set_bit(HPG_##flname, &(page->private)); }
+
+#define CLEARHPAGEFLAG(uname, flname)                          \
+static inline void ClearHPage##uname(struct page *page)                \
+       { clear_bit(HPG_##flname, &(page->private)); }
+#else
+#define TESTHPAGEFLAG(uname, flname)                           \
+static inline int HPage##uname(struct page *page)              \
+       { return 0; }
+
+#define SETHPAGEFLAG(uname, flname)                            \
+static inline void SetHPage##uname(struct page *page)          \
+       { }
+
+#define CLEARHPAGEFLAG(uname, flname)                          \
+static inline void ClearHPage##uname(struct page *page)                \
+       { }
+#endif
+
+#define HPAGEFLAG(uname, flname)                               \
+       TESTHPAGEFLAG(uname, flname)                            \
+       SETHPAGEFLAG(uname, flname)                             \
+       CLEARHPAGEFLAG(uname, flname)                           \
+
+/*
+ * Create functions associated with hugetlb page flags
+ */
+HPAGEFLAG(RestoreReserve, restore_reserve)
+HPAGEFLAG(Migratable, migratable)
+HPAGEFLAG(Temporary, temporary)
+HPAGEFLAG(Freed, freed)
+
 #ifdef CONFIG_HUGETLB_PAGE
 
 #define HSTATE_NAME_LEN 32
@@ -531,6 +609,20 @@ extern unsigned int default_hstate_idx;
 
 #define default_hstate (hstates[default_hstate_idx])
 
+/*
+ * hugetlb page subpool pointer located in hpage[1].private
+ */
+static inline struct hugepage_subpool *hugetlb_page_subpool(struct page *hpage)
+{
+       return (struct hugepage_subpool *)(hpage+1)->private;
+}
+
+static inline void hugetlb_set_page_subpool(struct page *hpage,
+                                       struct hugepage_subpool *subpool)
+{
+       set_page_private(hpage+1, (unsigned long)subpool);
+}
+
 static inline struct hstate *hstate_file(struct file *f)
 {
        return hstate_inode(file_inode(f));
@@ -770,8 +862,6 @@ static inline void huge_ptep_modify_prot_commit(struct vm_area_struct *vma,
 }
 #endif
 
-void set_page_huge_active(struct page *page);
-
 #else  /* CONFIG_HUGETLB_PAGE */
 struct hstate {};