lib/ext2fs/inline_data.c

   1 /*
   2  * inline_data.c --- data in inode
   3  *
   4  * Copyright (C) 2012 Zheng Liu <wenqing.lz@taobao.com>
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU library
   8  * General Public License, version 2.
   9  * %End-Header%
  10  */
  11
  12 #include "config.h"
  13 #include <stdio.h>
  14 #include <time.h>
  15
  16 #include "ext2_fs.h"
  17 #include "ext2_ext_attr.h"
  18
  19 #include "ext2fs.h"
  20 #include "ext2fsP.h"
  21
  22 struct ext2_inline_data {
  23         ext2_filsys fs;
  24         ext2_ino_t ino;
  25         size_t ea_size; /* the size of inline data in ea area */
  26         void *ea_data;
  27 };
  28
  29 static errcode_t ext2fs_inline_data_ea_set(struct ext2_inline_data *data)
  30 {
  31         struct ext2_xattr_handle *handle;
  32         errcode_t retval;
  33
  34         retval = ext2fs_xattrs_open(data->fs, data->ino, &handle);
  35         if (retval)
  36                 return retval;
  37
  38         retval = ext2fs_xattrs_read(handle);
  39         if (retval)
  40                 goto err;
  41
  42         retval = ext2fs_xattr_set(handle, "system.data",
  43                                   data->ea_data, data->ea_size);
  44         if (retval)
  45                 goto err;
  46
  47         retval = ext2fs_xattrs_write(handle);
  48
  49 err:
  50         (void) ext2fs_xattrs_close(&handle);
  51         return retval;
  52 }
  53
  54 static errcode_t ext2fs_inline_data_ea_get(struct ext2_inline_data *data)
  55 {
  56         struct ext2_xattr_handle *handle;
  57         errcode_t retval;
  58
  59         data->ea_size = 0;
  60         data->ea_data = 0;
  61
  62         retval = ext2fs_xattrs_open(data->fs, data->ino, &handle);
  63         if (retval)
  64                 return retval;
  65
  66         retval = ext2fs_xattrs_read(handle);
  67         if (retval)
  68                 goto err;
  69
  70         retval = ext2fs_xattr_get(handle, "system.data",
  71                                   (void **)&data->ea_data, &data->ea_size);
  72         if (retval)
  73                 goto err;
  74
  75 err:
  76         (void) ext2fs_xattrs_close(&handle);
  77         return retval;
  78 }
  79
  80 errcode_t ext2fs_inline_data_init(ext2_filsys fs, ext2_ino_t ino)
  81 {
  82         struct ext2_inline_data data;
  83
  84         data.fs = fs;
  85         data.ino = ino;
  86         data.ea_size = 0;
  87         data.ea_data = "";
  88         return ext2fs_inline_data_ea_set(&data);
  89 }
  90
  91 errcode_t ext2fs_inline_data_size(ext2_filsys fs, ext2_ino_t ino, size_t *size)
  92 {
  93         struct ext2_inode inode;
  94         struct ext2_inline_data data;
  95         errcode_t retval;
  96
  97         retval = ext2fs_read_inode(fs, ino, &inode);
  98         if (retval)
  99                 return retval;
 100
 101         if (!(inode.i_flags & EXT4_INLINE_DATA_FL))
 102                 return EXT2_ET_NO_INLINE_DATA;
 103
 104         data.fs = fs;
 105         data.ino = ino;
 106         retval = ext2fs_inline_data_ea_get(&data);
 107         if (retval)
 108                 return retval;
 109
 110         *size = EXT4_MIN_INLINE_DATA_SIZE + data.ea_size;
 111         return ext2fs_free_mem(&data.ea_data);
 112 }
 113
 114 int ext2fs_inline_data_dir_iterate(ext2_filsys fs, ext2_ino_t ino,
 115                                    void *priv_data)
 116 {
 117         struct dir_context *ctx;
 118         struct ext2_inode inode;
 119         struct ext2_dir_entry dirent;
 120         struct ext2_inline_data data;
 121         int ret = BLOCK_ABORT;
 122         e2_blkcnt_t blockcnt = 0;
 123
 124         ctx = (struct dir_context *)priv_data;
 125
 126         ctx->errcode = ext2fs_read_inode(fs, ino, &inode);
 127         if (ctx->errcode)
 128                 goto out;
 129
 130         if (!(inode.i_flags & EXT4_INLINE_DATA_FL)) {
 131                 ctx->errcode = EXT2_ET_NO_INLINE_DATA;
 132                 goto out;
 133         }
 134
 135         if (!LINUX_S_ISDIR(inode.i_mode)) {
 136                 ctx->errcode = EXT2_ET_NO_DIRECTORY;
 137                 goto out;
 138         }
 139         ret = 0;
 140
 141         /* we first check '.' and '..' dir */
 142         dirent.inode = ino;
 143         dirent.name_len = 1;
 144         ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(2), &dirent);
 145         dirent.name[0] = '.';
 146         dirent.name[1] = '\0';
 147         ctx->buf = (char *)&dirent;
 148         ext2fs_get_rec_len(fs, &dirent, &ctx->buflen);
 149         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 150         if (ret & BLOCK_ABORT)
 151                 goto out;
 152
 153         dirent.inode = ext2fs_le32_to_cpu(inode.i_block[0]);
 154         dirent.name_len = 2;
 155         ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(3), &dirent);
 156         dirent.name[0] = '.';
 157         dirent.name[1] = '.';
 158         dirent.name[2] = '\0';
 159         ctx->buf = (char *)&dirent;
 160         ext2fs_get_rec_len(fs, &dirent, &ctx->buflen);
 161         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 162         if (ret & BLOCK_INLINE_DATA_CHANGED) {
 163                 errcode_t err;
 164
 165                 inode.i_block[0] = ext2fs_cpu_to_le32(dirent.inode);
 166                 err = ext2fs_write_inode(fs, ino, &inode);
 167                 if (err)
 168                         goto out;
 169                 ret &= ~BLOCK_INLINE_DATA_CHANGED;
 170         }
 171         if (ret & BLOCK_ABORT)
 172                 goto out;
 173
 174         ctx->buf = (char *)inode.i_block + EXT4_INLINE_DATA_DOTDOT_SIZE;
 175         ctx->buflen = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DATA_DOTDOT_SIZE;
 176 #ifdef WORDS_BIGENDIAN
 177         ctx->errcode = ext2fs_dirent_swab_in2(fs, ctx->buf, ctx->buflen, 0);
 178         if (ctx->errcode) {
 179                 ret |= BLOCK_ABORT;
 180                 goto out;
 181         }
 182 #endif
 183         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 184         if (ret & BLOCK_INLINE_DATA_CHANGED) {
 185 #ifdef WORDS_BIGENDIAN
 186                 ctx->errcode = ext2fs_dirent_swab_out2(fs, ctx->buf,
 187                                                        ctx->buflen, 0);
 188                 if (ctx->errcode) {
 189                         ret |= BLOCK_ABORT;
 190                         goto out;
 191                 }
 192 #endif
 193                 ctx->errcode = ext2fs_write_inode(fs, ino, &inode);
 194                 if (ctx->errcode)
 195                         ret |= BLOCK_ABORT;
 196                 ret &= ~BLOCK_INLINE_DATA_CHANGED;
 197         }
 198         if (ret & BLOCK_ABORT)
 199                 goto out;
 200
 201         data.fs = fs;
 202         data.ino = ino;
 203         ctx->errcode = ext2fs_inline_data_ea_get(&data);
 204         if (ctx->errcode) {
 205                 ret |= BLOCK_ABORT;
 206                 goto out;
 207         }
 208         if (data.ea_size <= 0)
 209                 goto out;
 210
 211         ctx->buf = data.ea_data;
 212         ctx->buflen = data.ea_size;
 213 #ifdef WORDS_BIGENDIAN
 214         ctx.errcode = ext2fs_dirent_swab_in2(fs, ctx->buf, ctx->buflen, 0);
 215         if (ctx.errcode) {
 216                 ret |= BLOCK_ABORT;
 217                 goto out;
 218         }
 219 #endif
 220
 221         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 222         if (ret & BLOCK_INLINE_DATA_CHANGED) {
 223 #ifdef WORDS_BIGENDIAN
 224                 ctx->errcode = ext2fs_dirent_swab_out2(fs, ctx->buf,
 225                                                       ctx->buflen, 0);
 226                 if (ctx->errcode) {
 227                         ret |= BLOCK_ABORT;
 228                         goto out1;
 229                 }
 230 #endif
 231                 ctx->errcode = ext2fs_inline_data_ea_set(&data);
 232                 if (ctx->errcode)
 233                         ret |= BLOCK_ABORT;
 234         }
 235
 236 out1:
 237         ext2fs_free_mem(&data.ea_data);
 238         ctx->buf = 0;
 239
 240 out:
 241         ret &= ~(BLOCK_ABORT | BLOCK_INLINE_DATA_CHANGED);
 242         return ret;
 243 }
 244
 245 static errcode_t ext2fs_inline_data_ea_remove(ext2_filsys fs, ext2_ino_t ino)
 246 {
 247         struct ext2_xattr_handle *handle;
 248         errcode_t retval;
 249
 250         retval = ext2fs_xattrs_open(fs, ino, &handle);
 251         if (retval)
 252                 return retval;
 253
 254         retval = ext2fs_xattrs_read(handle);
 255         if (retval)
 256                 goto err;
 257
 258         retval = ext2fs_xattr_remove(handle, "system.data");
 259         if (retval)
 260                 goto err;
 261
 262         retval = ext2fs_xattrs_write(handle);
 263
 264 err:
 265         (void) ext2fs_xattrs_close(&handle);
 266         return retval;
 267 }
 268
 269 static errcode_t ext2fs_inline_data_convert_dir(ext2_filsys fs, ext2_ino_t ino,
 270                                                 char *bbuf, char *ibuf, int size)
 271 {
 272         struct ext2_dir_entry *dir, *dir2;
 273         struct ext2_dir_entry_tail *t;
 274         errcode_t retval;
 275         unsigned int offset;
 276         int csum_size = 0;
 277         int filetype = 0;
 278         int rec_len;
 279
 280         if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 281                                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
 282                 csum_size = sizeof(struct ext2_dir_entry_tail);
 283
 284         /* Create '.' and '..' */
 285         if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
 286                                       EXT2_FEATURE_INCOMPAT_FILETYPE))
 287                 filetype = EXT2_FT_DIR;
 288
 289         /*
 290          * Set up entry for '.'
 291          */
 292         dir = (struct ext2_dir_entry *) bbuf;
 293         dir->inode = ino;
 294         ext2fs_dirent_set_name_len(dir, 1);
 295         ext2fs_dirent_set_file_type(dir, filetype);
 296         dir->name[0] = '.';
 297         rec_len = (fs->blocksize - csum_size) - EXT2_DIR_REC_LEN(1);
 298         dir->rec_len = EXT2_DIR_REC_LEN(1);
 299
 300         /*
 301          * Set up entry for '..'
 302          */
 303         dir = (struct ext2_dir_entry *) (bbuf + dir->rec_len);
 304         dir->rec_len = EXT2_DIR_REC_LEN(2);
 305         dir->inode = ext2fs_le32_to_cpu(((__u32 *)ibuf)[0]);
 306         ext2fs_dirent_set_name_len(dir, 2);
 307         ext2fs_dirent_set_file_type(dir, filetype);
 308         dir->name[0] = '.';
 309         dir->name[1] = '.';
 310
 311         /*
 312          * Ajust the last rec_len
 313          */
 314         offset = EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2);
 315         dir = (struct ext2_dir_entry *) (bbuf + offset);
 316         memcpy(bbuf + offset, ibuf + EXT4_INLINE_DATA_DOTDOT_SIZE,
 317                size - EXT4_INLINE_DATA_DOTDOT_SIZE);
 318         size += EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) -
 319                 EXT4_INLINE_DATA_DOTDOT_SIZE;
 320
 321         do {
 322                 dir2 = dir;
 323                 retval = ext2fs_get_rec_len(fs, dir, &rec_len);
 324                 if (retval)
 325                         goto err;
 326                 offset += rec_len;
 327                 dir = (struct ext2_dir_entry *) (bbuf + offset);
 328         } while (offset < size);
 329         rec_len += fs->blocksize - csum_size - offset;
 330         retval = ext2fs_set_rec_len(fs, rec_len, dir2);
 331         if (retval)
 332                 goto err;
 333
 334         if (csum_size) {
 335                 t = EXT2_DIRENT_TAIL(bbuf, fs->blocksize);
 336                 ext2fs_initialize_dirent_tail(fs, t);
 337         }
 338
 339 err:
 340         return retval;
 341 }
 342
 343 errcode_t ext2fs_inline_data_expand(ext2_filsys fs, ext2_ino_t ino)
 344 {
 345         struct ext2_inode inode;
 346         struct ext2_inline_data data;
 347         errcode_t retval;
 348         blk64_t blk;
 349         char *inline_buf = 0;
 350         char *blk_buf = 0;
 351
 352         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 353
 354         retval = ext2fs_read_inode(fs, ino, &inode);
 355         if (retval)
 356                 return retval;
 357
 358         if (!(inode.i_flags & EXT4_INLINE_DATA_FL))
 359                 return EXT2_ET_NO_INLINE_DATA;
 360
 361         /* Get inline data first */
 362         data.fs = fs;
 363         data.ino = ino;
 364         retval = ext2fs_inline_data_ea_get(&data);
 365         if (retval)
 366                 return retval;
 367         retval = ext2fs_get_mem(EXT4_MIN_INLINE_DATA_SIZE + data.ea_size,
 368                                 &inline_buf);
 369         if (retval)
 370                 goto errout;
 371
 372         memcpy(inline_buf, (void *)inode.i_block, EXT4_MIN_INLINE_DATA_SIZE);
 373         if (data.ea_size > 0) {
 374                 memcpy(inline_buf + EXT4_MIN_INLINE_DATA_SIZE,
 375                        data.ea_data, data.ea_size);
 376         }
 377
 378 #ifdef WORDS_BIGENDIAN
 379         retval = ext2fs_dirent_swab_in2(fs, inline_buf,
 380                         data.ea_size + EXT4_MIN_INLINE_DATA_SIZE);
 381         if (retval)
 382                 goto errout;
 383 #endif
 384
 385         memset((void *)inode.i_block, 0, EXT4_MIN_INLINE_DATA_SIZE);
 386         retval = ext2fs_inline_data_ea_remove(fs, ino);
 387         if (retval)
 388                 goto errout;
 389
 390         retval = ext2fs_get_mem(fs->blocksize, &blk_buf);
 391         if (retval)
 392                 goto errout;
 393
 394         /* Adjust the rec_len */
 395         retval = ext2fs_inline_data_convert_dir(fs, ino, blk_buf, inline_buf,
 396                                                 EXT4_MIN_INLINE_DATA_SIZE +
 397                                                         data.ea_size);
 398         if (retval)
 399                 goto errout;
 400
 401         /* Allocate a new block */
 402         retval = ext2fs_new_block2(fs, 0, 0, &blk);
 403         if (retval)
 404                 goto errout;
 405         retval = ext2fs_write_dir_block4(fs, blk, blk_buf, 0, ino);
 406         if (retval)
 407                 goto errout;
 408
 409         /* Update inode */
 410         if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT3_FEATURE_INCOMPAT_EXTENTS))
 411                 inode.i_flags |= EXT4_EXTENTS_FL;
 412         inode.i_flags &= ~EXT4_INLINE_DATA_FL;
 413         ext2fs_iblk_set(fs, &inode, 1);
 414         inode.i_size = fs->blocksize;
 415         retval = ext2fs_bmap2(fs, ino, &inode, 0, BMAP_SET, 0, 0, &blk);
 416         if (retval)
 417                 goto errout;
 418         retval = ext2fs_write_inode(fs, ino, &inode);
 419         if (retval)
 420                 goto errout;
 421         ext2fs_block_alloc_stats2(fs, blk, +1);
 422
 423 errout:
 424         if (blk_buf)
 425                 ext2fs_free_mem(&blk_buf);
 426         if (inline_buf)
 427                 ext2fs_free_mem(&inline_buf);
 428         ext2fs_free_mem(&data.ea_data);
 429         return retval;
 430 }