old-patches/add-blkdiscard-ioctl

   1 ext4: add BLKDISCARD ioctl
   2
   3 The blkdicard ioctl previously only worked on block devices.  Allow
   4 this ioctl to work on ext4 files.
   5
   6 Google-Bug-Id: 11517631
   7
   8 Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
   9 ---
  10  fs/ext4/ext4.h    |   5 ++++
  11  fs/ext4/extents.c |  38 +++++++++++++++++++------
  12  fs/ext4/ioctl.c   | 138 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  13  3 files changed, 172 insertions(+), 9 deletions(-)
  14
  15 diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
  16 index 122cc74..68d88c7 100644
  17 --- a/fs/ext4/ext4.h
  18 +++ b/fs/ext4/ext4.h
  19 @@ -3208,6 +3208,8 @@ extern int ext4_check_blockref(const char *, unsigned int,
  20  /* extents.c */
  21  struct ext4_ext_path;
  22  struct ext4_extent;
  23 +typedef int (*extent_iterator_t)(struct inode *inode, struct extent_status *es,
  24 +                                unsigned int flags, void *private);
  25
  26  /*
  27   * Maximum number of logical blocks in a file; ext4_extent's ee_block is
  28 @@ -3252,6 +3254,9 @@ extern int ext4_find_delalloc_range(struct inode *inode,
  29                                     ext4_lblk_t lblk_end);
  30  extern int ext4_find_delalloc_cluster(struct inode *inode, ext4_lblk_t lblk);
  31  extern ext4_lblk_t ext4_ext_next_allocated_block(struct ext4_ext_path *path);
  32 +extern int ext4_extent_iterator(struct inode *inode,
  33 +                               ext4_lblk_t block, ext4_lblk_t num,
  34 +                               extent_iterator_t callback, void *private);
  35  extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
  36                         __u64 start, __u64 len);
  37  extern int ext4_ext_precache(struct inode *inode);
  38 diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
  39 index 572fb4346..c32f0c1 100644
  40 --- a/fs/ext4/extents.c
  41 +++ b/fs/ext4/extents.c
  42 @@ -2150,9 +2150,13 @@ cleanup:
  43         return err;
  44  }
  45
  46 -static int ext4_fill_fiemap_extents(struct inode *inode,
  47 -                                   ext4_lblk_t block, ext4_lblk_t num,
  48 -                                   struct fiemap_extent_info *fieinfo)
  49 +
  50 +typedef int (*extent_iterator_t)(struct inode *inode, struct extent_status *es,
  51 +                                unsigned int flags, void *private);
  52 +
  53 +int ext4_extent_iterator(struct inode *inode,
  54 +                        ext4_lblk_t block, ext4_lblk_t num,
  55 +                        extent_iterator_t callback, void *private)
  56  {
  57         struct ext4_ext_path *path = NULL;
  58         struct ext4_extent *ex;
  59 @@ -2161,7 +2165,6 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
  60         ext4_lblk_t last = block + num;
  61         int exists, depth = 0, err = 0;
  62         unsigned int flags = 0;
  63 -       unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
  64
  65         while (block < last && block != EXT_MAX_BLOCKS) {
  66                 num = last - block;
  67 @@ -2278,11 +2281,7 @@ static int ext4_fill_fiemap_extents(struct inode *inode,
  68                 }
  69
  70                 if (exists) {
  71 -                       err = fiemap_fill_next_extent(fieinfo,
  72 -                               (__u64)es.es_lblk << blksize_bits,
  73 -                               (__u64)es.es_pblk << blksize_bits,
  74 -                               (__u64)es.es_len << blksize_bits,
  75 -                               flags);
  76 +                       err = callback(inode, &es, flags, private);
  77                         if (err < 0)
  78                                 break;
  79                         if (err == 1) {
  80 @@ -2341,6 +2340,27 @@ static ext4_lblk_t ext4_ext_determine_hole(struct inode *inode,
  81         return len;
  82  }
  83
  84 +static int call_fill_fiemap(struct inode *inode, struct extent_status *es,
  85 +                           unsigned int flags, void *private)
  86 +{
  87 +       unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
  88 +
  89 +       return fiemap_fill_next_extent(private,
  90 +                                      (__u64)es->es_lblk << blksize_bits,
  91 +                                      (__u64)es->es_pblk << blksize_bits,
  92 +                                      (__u64)es->es_len << blksize_bits,
  93 +                                      flags);
  94 +}
  95 +
  96 +static int ext4_fill_fiemap_extents(struct inode *inode,
  97 +                                   ext4_lblk_t block, ext4_lblk_t num,
  98 +                                   struct fiemap_extent_info *fieinfo)
  99 +{
 100 +       return ext4_extent_iterator(inode, block, num,
 101 +                                   call_fill_fiemap, fieinfo);
 102 +}
 103 +
 104 +
 105  /*
 106   * ext4_ext_put_gap_in_cache:
 107   * calculate boundaries of the gap that the requested block fits into
 108 diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
 109 index 6c6be1d..fa8bac0 100644
 110 --- a/fs/ext4/ioctl.c
 111 +++ b/fs/ext4/ioctl.c
 112 @@ -468,6 +468,132 @@ static int write_user_mdata(unsigned long arg,
 113  }
 114  #endif
 115
 116 +static int discard_callback(struct inode *inode, struct extent_status *es,
 117 +                           unsigned int flags, void *private)
 118 +{
 119 +       struct ext4_map_blocks *map = private;
 120 +       ext4_lblk_t es_lblk = es->es_lblk;
 121 +       ext4_lblk_t es_len = es->es_len;
 122 +       ext4_fsblk_t es_pblk = es->es_pblk;
 123 +
 124 +       if (flags & (FIEMAP_EXTENT_UNKNOWN |
 125 +                    FIEMAP_EXTENT_ENCODED |
 126 +                    FIEMAP_EXTENT_DATA_ENCRYPTED |
 127 +                    FIEMAP_EXTENT_DELALLOC |
 128 +                    FIEMAP_EXTENT_DATA_TAIL |
 129 +                    FIEMAP_EXTENT_DATA_INLINE |
 130 +                    FIEMAP_EXTENT_NOT_ALIGNED |
 131 +                    FIEMAP_EXTENT_SHARED))
 132 +               return 0;
 133 +
 134 +       if (es_lblk < map->m_lblk) {
 135 +               ext4_lblk_t d = map->m_lblk - es_lblk;
 136 +               if (d > es_len)
 137 +                       return 0;
 138 +               es_lblk += d;
 139 +               es_pblk += d;
 140 +               es_len -= d;
 141 +       }
 142 +
 143 +       if (es_lblk + es_len > map->m_lblk + map->m_len)
 144 +               es_len -= es_lblk + es_len - (map->m_lblk + map->m_len);
 145 +#ifdef BLKDISCARD_DEBUG
 146 +       ext4_msg(inode->i_sb, KERN_NOTICE, "discard: %llu len %lu",
 147 +                (unsigned long long) es_pblk, (unsigned long) es_len);
 148 +       return 0;
 149 +#else
 150 +       return sb_issue_discard(inode->i_sb, es_pblk, es_len, GFP_KERNEL, 0);
 151 +#endif
 152 +}
 153 +
 154 +static int blkdiscard_inode(struct inode *inode, u64 start_offset, u64 len)
 155 +{
 156 +       struct super_block *sb = inode->i_sb;
 157 +       struct ext4_map_blocks map;
 158 +       unsigned int num;
 159 +
 160 +       if (!S_ISREG(inode->i_mode))
 161 +               return -EINVAL;
 162 +
 163 +       if (!blk_queue_discard(bdev_get_queue(sb->s_bdev)))
 164 +              return -EOPNOTSUPP;
 165 +
 166 +       if (!bdev_discard_zeroes_data(sb->s_bdev) && !capable(CAP_SYS_ADMIN))
 167 +              return -EOPNOTSUPP;
 168 +
 169 +       num = start_offset & (sb->s_blocksize - 1);
 170 +       if (num) {
 171 +               num = sb->s_blocksize - num;
 172 +               start_offset += num;
 173 +               len = (len > num) ? len - num : 0;
 174 +       }
 175 +       if (len == 0)
 176 +               return 0;
 177 +       if (start_offset > sb->s_maxbytes)
 178 +               return -EFBIG;
 179 +       if (len > sb->s_maxbytes || (sb->s_maxbytes - len) < start_offset)
 180 +               len = sb->s_maxbytes - start_offset;
 181 +
 182 +       map.m_lblk = start_offset >> sb->s_blocksize_bits;
 183 +       map.m_len = len >> sb->s_blocksize_bits;
 184 +
 185 +#ifdef BLKDISCARD_DEBUG
 186 +       ext4_msg(sb, KERN_NOTICE, "blkdiscard range: %lu len %lu",
 187 +                (unsigned long) map.m_lblk, (unsigned long) map.m_len);
 188 +#endif
 189 +
 190 +       if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
 191 +               return ext4_extent_iterator(inode, map.m_lblk, map.m_len,
 192 +                                           discard_callback, &map);
 193 +
 194 +       num = map.m_len;
 195 +       while (num) {
 196 +               int ret = ext4_map_blocks(NULL, inode, &map, 0);
 197 +
 198 +               if (ret < 0)
 199 +                       return ret;
 200 +
 201 +               if (ret == 0) {
 202 +#ifdef BLKDISCARD_DEBUG
 203 +                       ext4_msg(sb, KERN_NOTICE,
 204 +                                "skip: lblk %lu len %lu ret %lu num %lu",
 205 +                                (unsigned long) map.m_lblk,
 206 +                                (unsigned long) map.m_len,
 207 +                                (unsigned long) ret,
 208 +                                (unsigned long) num);
 209 +#endif
 210 +                       map.m_lblk++;
 211 +                       num--;
 212 +                       continue;
 213 +               }
 214 +#ifdef BLKDISCARD_DEBUG
 215 +               ext4_msg(sb, KERN_NOTICE,
 216 +                        "walk: lblk %lu pblk %llu len %lu ret %lu num %lu",
 217 +                        (unsigned long) map.m_lblk,
 218 +                        (unsigned long long) map.m_pblk,
 219 +                        (unsigned long) map.m_len,
 220 +                        (unsigned long) ret,
 221 +                        (unsigned long) num);
 222 +#endif
 223 +               if (ret > num)
 224 +                       ret = num;
 225 +               map.m_lblk += ret;
 226 +               num -= ret;
 227 +               map.m_len = num;
 228 +
 229 +#ifdef BLKDISCARD_DEBUG
 230 +               ext4_msg(sb, KERN_NOTICE, "discard: %llu len %lu",
 231 +                        (unsigned long long) map.m_pblk, (unsigned long) ret);
 232 +#else
 233 +               ret = sb_issue_discard(sb, map.m_pblk, ret,
 234 +                                      GFP_KERNEL, 0);
 235 +               if (ret)
 236 +                       return ret;
 237 +#endif
 238 +       }
 239 +       return 0;
 240 +}
 241 +
 242  long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 243  {
 244         struct inode *inode = file_inode(filp);
 245 @@ -1006,6 +1132,17 @@ encryption_policy_out:
 246                 return -EOPNOTSUPP;
 247  #endif
 248         }
 249 +       case BLKDISCARD: {
 250 +               uint64_t range[2];
 251 +
 252 +               if (!(filp->f_mode & FMODE_WRITE))
 253 +                       return -EBADF;
 254 +
 255 +               if (copy_from_user(range, (void __user *)arg, sizeof(range)))
 256 +                       return -EFAULT;
 257 +
 258 +               return blkdiscard_inode(file_inode(filp), range[0], range[1]);
 259 +       }
 260         default:
 261                 return -ENOTTY;
 262         }
 263 @@ -1075,6 +1212,7 @@ long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 264         case EXT4_IOC_GET_ENCRYPTION_METADATA:
 265         case EXT4_IOC_SET_ENCRYPTION_METADATA:
 266         case EXT4_IOC_GET_ENCRYPTED_FILENAME:
 267 +       case BLKDISCARD:
 268                 break;
 269         default:
 270                 return -ENOIOCTLCMD;