fs/erofs/zdata.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) 2018 HUAWEI, Inc.
   4  *             https://www.huawei.com/
   5  */
   6 #ifndef __EROFS_FS_ZDATA_H
   7 #define __EROFS_FS_ZDATA_H
   8
   9 #include "internal.h"
  10 #include "zpvec.h"
  11
  12 #define Z_EROFS_PCLUSTER_MAX_PAGES      (Z_EROFS_PCLUSTER_MAX_SIZE / PAGE_SIZE)
  13 #define Z_EROFS_NR_INLINE_PAGEVECS      3
  14
  15 /*
  16  * Structure fields follow one of the following exclusion rules.
  17  *
  18  * I: Modifiable by initialization/destruction paths and read-only
  19  *    for everyone else;
  20  *
  21  * L: Field should be protected by pageset lock;
  22  *
  23  * A: Field should be accessed / updated in atomic for parallelized code.
  24  */
  25 struct z_erofs_collection {
  26         struct mutex lock;
  27
  28         /* I: page offset of start position of decompression */
  29         unsigned short pageofs;
  30
  31         /* L: maximum relative page index in pagevec[] */
  32         unsigned short nr_pages;
  33
  34         /* L: total number of pages in pagevec[] */
  35         unsigned int vcnt;
  36
  37         union {
  38                 /* L: inline a certain number of pagevecs for bootstrap */
  39                 erofs_vtptr_t pagevec[Z_EROFS_NR_INLINE_PAGEVECS];
  40
  41                 /* I: can be used to free the pcluster by RCU. */
  42                 struct rcu_head rcu;
  43         };
  44 };
  45
  46 #define Z_EROFS_PCLUSTER_FULL_LENGTH    0x00000001
  47 #define Z_EROFS_PCLUSTER_LENGTH_BIT     1
  48
  49 /*
  50  * let's leave a type here in case of introducing
  51  * another tagged pointer later.
  52  */
  53 typedef void *z_erofs_next_pcluster_t;
  54
  55 struct z_erofs_pcluster {
  56         struct erofs_workgroup obj;
  57         struct z_erofs_collection primary_collection;
  58
  59         /* A: point to next chained pcluster or TAILs */
  60         z_erofs_next_pcluster_t next;
  61
  62         /* A: lower limit of decompressed length and if full length or not */
  63         unsigned int length;
  64
  65         /* I: page offset of inline compressed data */
  66         unsigned short pageofs_in;
  67
  68         union {
  69                 /* I: physical cluster size in pages */
  70                 unsigned short pclusterpages;
  71
  72                 /* I: tailpacking inline compressed size */
  73                 unsigned short tailpacking_size;
  74         };
  75
  76         /* I: compression algorithm format */
  77         unsigned char algorithmformat;
  78
  79         /* A: compressed pages (can be cached or inplaced pages) */
  80         struct page *compressed_pages[];
  81 };
  82
  83 #define z_erofs_primarycollection(pcluster) (&(pcluster)->primary_collection)
  84
  85 /* let's avoid the valid 32-bit kernel addresses */
  86
  87 /* the chained workgroup has't submitted io (still open) */
  88 #define Z_EROFS_PCLUSTER_TAIL           ((void *)0x5F0ECAFE)
  89 /* the chained workgroup has already submitted io */
  90 #define Z_EROFS_PCLUSTER_TAIL_CLOSED    ((void *)0x5F0EDEAD)
  91
  92 #define Z_EROFS_PCLUSTER_NIL            (NULL)
  93
  94 struct z_erofs_decompressqueue {
  95         struct super_block *sb;
  96         atomic_t pending_bios;
  97         z_erofs_next_pcluster_t head;
  98
  99         union {
 100                 wait_queue_head_t wait;
 101                 struct work_struct work;
 102         } u;
 103 };
 104
 105 static inline bool z_erofs_is_inline_pcluster(struct z_erofs_pcluster *pcl)
 106 {
 107         return !pcl->obj.index;
 108 }
 109
 110 static inline unsigned int z_erofs_pclusterpages(struct z_erofs_pcluster *pcl)
 111 {
 112         if (z_erofs_is_inline_pcluster(pcl))
 113                 return 1;
 114         return pcl->pclusterpages;
 115 }
 116
 117 #define Z_EROFS_ONLINEPAGE_COUNT_BITS   2
 118 #define Z_EROFS_ONLINEPAGE_COUNT_MASK   ((1 << Z_EROFS_ONLINEPAGE_COUNT_BITS) - 1)
 119 #define Z_EROFS_ONLINEPAGE_INDEX_SHIFT  (Z_EROFS_ONLINEPAGE_COUNT_BITS)
 120
 121 /*
 122  * waiters (aka. ongoing_packs): # to unlock the page
 123  * sub-index: 0 - for partial page, >= 1 full page sub-index
 124  */
 125 typedef atomic_t z_erofs_onlinepage_t;
 126
 127 /* type punning */
 128 union z_erofs_onlinepage_converter {
 129         z_erofs_onlinepage_t *o;
 130         unsigned long *v;
 131 };
 132
 133 static inline unsigned int z_erofs_onlinepage_index(struct page *page)
 134 {
 135         union z_erofs_onlinepage_converter u;
 136
 137         DBG_BUGON(!PagePrivate(page));
 138         u.v = &page_private(page);
 139
 140         return atomic_read(u.o) >> Z_EROFS_ONLINEPAGE_INDEX_SHIFT;
 141 }
 142
 143 static inline void z_erofs_onlinepage_init(struct page *page)
 144 {
 145         union {
 146                 z_erofs_onlinepage_t o;
 147                 unsigned long v;
 148         /* keep from being unlocked in advance */
 149         } u = { .o = ATOMIC_INIT(1) };
 150
 151         set_page_private(page, u.v);
 152         smp_wmb();
 153         SetPagePrivate(page);
 154 }
 155
 156 static inline void z_erofs_onlinepage_fixup(struct page *page,
 157         uintptr_t index, bool down)
 158 {
 159         union z_erofs_onlinepage_converter u = { .v = &page_private(page) };
 160         int orig, orig_index, val;
 161
 162 repeat:
 163         orig = atomic_read(u.o);
 164         orig_index = orig >> Z_EROFS_ONLINEPAGE_INDEX_SHIFT;
 165         if (orig_index) {
 166                 if (!index)
 167                         return;
 168
 169                 DBG_BUGON(orig_index != index);
 170         }
 171
 172         val = (index << Z_EROFS_ONLINEPAGE_INDEX_SHIFT) |
 173                 ((orig & Z_EROFS_ONLINEPAGE_COUNT_MASK) + (unsigned int)down);
 174         if (atomic_cmpxchg(u.o, orig, val) != orig)
 175                 goto repeat;
 176 }
 177
 178 static inline void z_erofs_onlinepage_endio(struct page *page)
 179 {
 180         union z_erofs_onlinepage_converter u;
 181         unsigned int v;
 182
 183         DBG_BUGON(!PagePrivate(page));
 184         u.v = &page_private(page);
 185
 186         v = atomic_dec_return(u.o);
 187         if (!(v & Z_EROFS_ONLINEPAGE_COUNT_MASK)) {
 188                 set_page_private(page, 0);
 189                 ClearPagePrivate(page);
 190                 if (!PageError(page))
 191                         SetPageUptodate(page);
 192                 unlock_page(page);
 193         }
 194         erofs_dbg("%s, page %p value %x", __func__, page, atomic_read(u.o));
 195 }
 196
 197 #define Z_EROFS_VMAP_ONSTACK_PAGES      \
 198         min_t(unsigned int, THREAD_SIZE / 8 / sizeof(struct page *), 96U)
 199 #define Z_EROFS_VMAP_GLOBAL_PAGES       2048
 200
 201 #endif