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         char *old_buf;
 124         unsigned int old_buflen;
 125         int old_flags;
 126
 127         ctx = (struct dir_context *)priv_data;
 128         old_buf = ctx->buf;
 129         old_buflen = ctx->buflen;
 130         old_flags = ctx->flags;
 131         ctx->flags |= DIRENT_FLAG_INCLUDE_INLINE_DATA;
 132
 133         ctx->errcode = ext2fs_read_inode(fs, ino, &inode);
 134         if (ctx->errcode)
 135                 goto out;
 136
 137         if (!(inode.i_flags & EXT4_INLINE_DATA_FL)) {
 138                 ctx->errcode = EXT2_ET_NO_INLINE_DATA;
 139                 goto out;
 140         }
 141
 142         if (!LINUX_S_ISDIR(inode.i_mode)) {
 143                 ctx->errcode = EXT2_ET_NO_DIRECTORY;
 144                 goto out;
 145         }
 146         ret = 0;
 147
 148         /* we first check '.' and '..' dir */
 149         dirent.inode = ino;
 150         dirent.name_len = 1;
 151         ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(2), &dirent);
 152         dirent.name[0] = '.';
 153         dirent.name[1] = '\0';
 154         ctx->buf = (char *)&dirent;
 155         ext2fs_get_rec_len(fs, &dirent, &ctx->buflen);
 156         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 157         if (ret & BLOCK_ABORT)
 158                 goto out;
 159
 160         dirent.inode = ext2fs_le32_to_cpu(inode.i_block[0]);
 161         dirent.name_len = 2;
 162         ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(3), &dirent);
 163         dirent.name[0] = '.';
 164         dirent.name[1] = '.';
 165         dirent.name[2] = '\0';
 166         ctx->buf = (char *)&dirent;
 167         ext2fs_get_rec_len(fs, &dirent, &ctx->buflen);
 168         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 169         if (ret & BLOCK_INLINE_DATA_CHANGED) {
 170                 errcode_t err;
 171
 172                 inode.i_block[0] = ext2fs_cpu_to_le32(dirent.inode);
 173                 err = ext2fs_write_inode(fs, ino, &inode);
 174                 if (err)
 175                         goto out;
 176                 ret &= ~BLOCK_INLINE_DATA_CHANGED;
 177         }
 178         if (ret & BLOCK_ABORT)
 179                 goto out;
 180
 181         ctx->buf = (char *)inode.i_block + EXT4_INLINE_DATA_DOTDOT_SIZE;
 182         ctx->buflen = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DATA_DOTDOT_SIZE;
 183 #ifdef WORDS_BIGENDIAN
 184         ctx->errcode = ext2fs_dirent_swab_in2(fs, ctx->buf, ctx->buflen, 0);
 185         if (ctx->errcode) {
 186                 ret |= BLOCK_ABORT;
 187                 goto out;
 188         }
 189 #endif
 190         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 191         if (ret & BLOCK_INLINE_DATA_CHANGED) {
 192 #ifdef WORDS_BIGENDIAN
 193                 ctx->errcode = ext2fs_dirent_swab_out2(fs, ctx->buf,
 194                                                        ctx->buflen, 0);
 195                 if (ctx->errcode) {
 196                         ret |= BLOCK_ABORT;
 197                         goto out;
 198                 }
 199 #endif
 200                 ctx->errcode = ext2fs_write_inode(fs, ino, &inode);
 201                 if (ctx->errcode)
 202                         ret |= BLOCK_ABORT;
 203                 ret &= ~BLOCK_INLINE_DATA_CHANGED;
 204         }
 205         if (ret & BLOCK_ABORT)
 206                 goto out;
 207
 208         data.fs = fs;
 209         data.ino = ino;
 210         ctx->errcode = ext2fs_inline_data_ea_get(&data);
 211         if (ctx->errcode) {
 212                 ret |= BLOCK_ABORT;
 213                 goto out;
 214         }
 215         if (data.ea_size <= 0)
 216                 goto out;
 217
 218         ctx->buf = data.ea_data;
 219         ctx->buflen = data.ea_size;
 220 #ifdef WORDS_BIGENDIAN
 221         ctx->errcode = ext2fs_dirent_swab_in2(fs, ctx->buf, ctx->buflen, 0);
 222         if (ctx->errcode) {
 223                 ret |= BLOCK_ABORT;
 224                 goto out;
 225         }
 226 #endif
 227
 228         ret |= ext2fs_process_dir_block(fs, 0, blockcnt++, 0, 0, priv_data);
 229         if (ret & BLOCK_INLINE_DATA_CHANGED) {
 230 #ifdef WORDS_BIGENDIAN
 231                 ctx->errcode = ext2fs_dirent_swab_out2(fs, ctx->buf,
 232                                                       ctx->buflen, 0);
 233                 if (ctx->errcode) {
 234                         ret |= BLOCK_ABORT;
 235                         goto out1;
 236                 }
 237 #endif
 238                 ctx->errcode = ext2fs_inline_data_ea_set(&data);
 239                 if (ctx->errcode)
 240                         ret |= BLOCK_ABORT;
 241         }
 242
 243 out1:
 244         ext2fs_free_mem(&data.ea_data);
 245 out:
 246         ctx->buf = old_buf;
 247         ctx->buflen = old_buflen;
 248         ctx->flags = old_flags;
 249         ret &= ~(BLOCK_ABORT | BLOCK_INLINE_DATA_CHANGED);
 250         return ret;
 251 }
 252
 253 errcode_t ext2fs_inline_data_ea_remove(ext2_filsys fs, ext2_ino_t ino)
 254 {
 255         struct ext2_xattr_handle *handle;
 256         errcode_t retval;
 257
 258         retval = ext2fs_xattrs_open(fs, ino, &handle);
 259         if (retval)
 260                 return retval;
 261
 262         retval = ext2fs_xattrs_read(handle);
 263         if (retval)
 264                 goto err;
 265
 266         retval = ext2fs_xattr_remove(handle, "system.data");
 267         if (retval)
 268                 goto err;
 269
 270         retval = ext2fs_xattrs_write(handle);
 271
 272 err:
 273         (void) ext2fs_xattrs_close(&handle);
 274         return retval;
 275 }
 276
 277 static errcode_t ext2fs_inline_data_convert_dir(ext2_filsys fs, ext2_ino_t ino,
 278                                                 char *bbuf, char *ibuf, int size)
 279 {
 280         struct ext2_dir_entry *dir, *dir2;
 281         struct ext2_dir_entry_tail *t;
 282         errcode_t retval;
 283         unsigned int offset;
 284         int csum_size = 0;
 285         int filetype = 0;
 286         int rec_len;
 287
 288         if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
 289                                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
 290                 csum_size = sizeof(struct ext2_dir_entry_tail);
 291
 292         /* Create '.' and '..' */
 293         if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
 294                                       EXT2_FEATURE_INCOMPAT_FILETYPE))
 295                 filetype = EXT2_FT_DIR;
 296
 297         /*
 298          * Set up entry for '.'
 299          */
 300         dir = (struct ext2_dir_entry *) bbuf;
 301         dir->inode = ino;
 302         ext2fs_dirent_set_name_len(dir, 1);
 303         ext2fs_dirent_set_file_type(dir, filetype);
 304         dir->name[0] = '.';
 305         rec_len = (fs->blocksize - csum_size) - EXT2_DIR_REC_LEN(1);
 306         dir->rec_len = EXT2_DIR_REC_LEN(1);
 307
 308         /*
 309          * Set up entry for '..'
 310          */
 311         dir = (struct ext2_dir_entry *) (bbuf + dir->rec_len);
 312         dir->rec_len = EXT2_DIR_REC_LEN(2);
 313         dir->inode = ext2fs_le32_to_cpu(((__u32 *)ibuf)[0]);
 314         ext2fs_dirent_set_name_len(dir, 2);
 315         ext2fs_dirent_set_file_type(dir, filetype);
 316         dir->name[0] = '.';
 317         dir->name[1] = '.';
 318
 319         /*
 320          * Ajust the last rec_len
 321          */
 322         offset = EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2);
 323         dir = (struct ext2_dir_entry *) (bbuf + offset);
 324         memcpy(bbuf + offset, ibuf + EXT4_INLINE_DATA_DOTDOT_SIZE,
 325                size - EXT4_INLINE_DATA_DOTDOT_SIZE);
 326         size += EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) -
 327                 EXT4_INLINE_DATA_DOTDOT_SIZE;
 328
 329         do {
 330                 dir2 = dir;
 331                 retval = ext2fs_get_rec_len(fs, dir, &rec_len);
 332                 if (retval)
 333                         goto err;
 334                 offset += rec_len;
 335                 dir = (struct ext2_dir_entry *) (bbuf + offset);
 336         } while (offset < size);
 337         rec_len += fs->blocksize - csum_size - offset;
 338         retval = ext2fs_set_rec_len(fs, rec_len, dir2);
 339         if (retval)
 340                 goto err;
 341
 342         if (csum_size) {
 343                 t = EXT2_DIRENT_TAIL(bbuf, fs->blocksize);
 344                 ext2fs_initialize_dirent_tail(fs, t);
 345         }
 346
 347 err:
 348         return retval;
 349 }
 350
 351 static errcode_t
 352 ext2fs_inline_data_dir_expand(ext2_filsys fs, ext2_ino_t ino,
 353                               struct ext2_inode *inode, char *buf, size_t size)
 354 {
 355         errcode_t retval;
 356         blk64_t blk;
 357         char *blk_buf;
 358
 359         retval = ext2fs_get_memzero(fs->blocksize, &blk_buf);
 360         if (retval)
 361                 return retval;
 362
 363 #ifdef WORDS_BIGENDIAN
 364         retval = ext2fs_dirent_swab_in2(fs, buf, size, 0);
 365         if (retval)
 366                 goto errout;
 367 #endif
 368
 369         /* Adjust the rec_len */
 370         retval = ext2fs_inline_data_convert_dir(fs, ino, blk_buf, buf, size);
 371         /* Allocate a new block */
 372         retval = ext2fs_new_block2(fs, 0, 0, &blk);
 373         if (retval)
 374                 goto errout;
 375         retval = ext2fs_write_dir_block4(fs, blk, blk_buf, 0, ino);
 376         if (retval)
 377                 goto errout;
 378
 379         /* Update inode */
 380         if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT3_FEATURE_INCOMPAT_EXTENTS))
 381                 inode->i_flags |= EXT4_EXTENTS_FL;
 382         inode->i_flags &= ~EXT4_INLINE_DATA_FL;
 383         retval = ext2fs_iblk_add_blocks(fs, inode, 1);
 384         if (retval)
 385                 goto errout;
 386         inode->i_size = fs->blocksize;
 387         retval = ext2fs_bmap2(fs, ino, inode, 0, BMAP_SET, 0, 0, &blk);
 388         if (retval)
 389                 goto errout;
 390         retval = ext2fs_write_inode(fs, ino, inode);
 391         if (retval)
 392                 goto errout;
 393         ext2fs_block_alloc_stats(fs, blk, +1);
 394
 395 errout:
 396         ext2fs_free_mem(&blk_buf);
 397         return retval;
 398 }
 399
 400 static errcode_t
 401 ext2fs_inline_data_file_expand(ext2_filsys fs, ext2_ino_t ino,
 402                                struct ext2_inode *inode, char *buf, size_t size)
 403 {
 404         ext2_file_t e2_file;
 405         errcode_t retval;
 406
 407         /* Update inode */
 408         if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
 409                                       EXT3_FEATURE_INCOMPAT_EXTENTS)) {
 410                 int i;
 411                 struct ext3_extent_header *eh;
 412
 413                 eh = (struct ext3_extent_header *) &inode->i_block[0];
 414                 eh->eh_depth = 0;
 415                 eh->eh_entries = 0;
 416                 eh->eh_magic = EXT3_EXT_MAGIC;
 417                 i = (sizeof(inode->i_block) - sizeof(*eh)) /
 418                         sizeof(struct ext3_extent);
 419                 eh->eh_max = ext2fs_cpu_to_le16(i);
 420                 inode->i_flags |= EXT4_EXTENTS_FL;
 421         }
 422         inode->i_flags &= ~EXT4_INLINE_DATA_FL;
 423         inode->i_size = 0;
 424         retval = ext2fs_write_inode(fs, ino, inode);
 425         if (retval)
 426                 return retval;
 427
 428         /* Write out the block buffer */
 429         retval = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &e2_file);
 430         if (retval)
 431                 return retval;
 432         retval = ext2fs_file_write(e2_file, buf, size, 0);
 433         ext2fs_file_close(e2_file);
 434         return retval;
 435 }
 436
 437 errcode_t ext2fs_inline_data_expand(ext2_filsys fs, ext2_ino_t ino)
 438 {
 439         struct ext2_inode inode;
 440         struct ext2_inline_data data;
 441         errcode_t retval;
 442         size_t inline_size;
 443         char *inline_buf = 0;
 444
 445         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 446
 447         retval = ext2fs_read_inode(fs, ino, &inode);
 448         if (retval)
 449                 return retval;
 450
 451         if (!(inode.i_flags & EXT4_INLINE_DATA_FL))
 452                 return EXT2_ET_NO_INLINE_DATA;
 453
 454         data.fs = fs;
 455         data.ino = ino;
 456         retval = ext2fs_inline_data_ea_get(&data);
 457         if (retval)
 458                 return retval;
 459         inline_size = data.ea_size + EXT4_MIN_INLINE_DATA_SIZE;
 460         retval = ext2fs_get_mem(inline_size, &inline_buf);
 461         if (retval)
 462                 goto errout;
 463
 464         memcpy(inline_buf, (void *)inode.i_block, EXT4_MIN_INLINE_DATA_SIZE);
 465         if (data.ea_size > 0) {
 466                 memcpy(inline_buf + EXT4_MIN_INLINE_DATA_SIZE,
 467                        data.ea_data, data.ea_size);
 468         }
 469
 470         memset((void *)inode.i_block, 0, EXT4_MIN_INLINE_DATA_SIZE);
 471         /*
 472          * NOTE: We must do this write -> ea_remove -> read cycle here because
 473          * removing the inline data EA can free the EA block, which is a change
 474          * that our stack copy of the inode will never see.  If that happens,
 475          * we can end up with the EA block and lblk 0 pointing to the same
 476          * pblk, which is bad news.
 477          */
 478         retval = ext2fs_write_inode(fs, ino, &inode);
 479         if (retval)
 480                 goto errout;
 481         retval = ext2fs_inline_data_ea_remove(fs, ino);
 482         if (retval)
 483                 goto errout;
 484         retval = ext2fs_read_inode(fs, ino, &inode);
 485         if (retval)
 486                 goto errout;
 487
 488         if (LINUX_S_ISDIR(inode.i_mode)) {
 489                 retval = ext2fs_inline_data_dir_expand(fs, ino, &inode,
 490                                                 inline_buf, inline_size);
 491         } else {
 492                 retval = ext2fs_inline_data_file_expand(fs, ino, &inode,
 493                                                 inline_buf, inline_size);
 494         }
 495
 496 errout:
 497         if (inline_buf)
 498                 ext2fs_free_mem(&inline_buf);
 499         ext2fs_free_mem(&data.ea_data);
 500         return retval;
 501 }
 502
 503 /*
 504  * When caller uses this function to retrieve the inline data, it must
 505  * allocate a buffer which has the size of inline data.  The size of
 506  * inline data can be know by ext2fs_inline_data_get_size().
 507  */
 508 errcode_t ext2fs_inline_data_get(ext2_filsys fs, ext2_ino_t ino,
 509                                  struct ext2_inode *inode,
 510                                  void *buf, size_t *size)
 511 {
 512         struct ext2_inode inode_buf;
 513         struct ext2_inline_data data;
 514         errcode_t retval;
 515
 516         if (!inode) {
 517                 retval = ext2fs_read_inode(fs, ino, &inode_buf);
 518                 if (retval)
 519                         return retval;
 520                 inode = &inode_buf;
 521         }
 522
 523         data.fs = fs;
 524         data.ino = ino;
 525         retval = ext2fs_inline_data_ea_get(&data);
 526         if (retval)
 527                 return retval;
 528
 529         memcpy(buf, (void *)inode->i_block, EXT4_MIN_INLINE_DATA_SIZE);
 530         if (data.ea_size > 0)
 531                 memcpy(buf + EXT4_MIN_INLINE_DATA_SIZE,
 532                        data.ea_data, data.ea_size);
 533
 534         if (size)
 535                 *size = EXT4_MIN_INLINE_DATA_SIZE + data.ea_size;
 536         ext2fs_free_mem(&data.ea_data);
 537         return 0;
 538 }
 539
 540 errcode_t ext2fs_inline_data_set(ext2_filsys fs, ext2_ino_t ino,
 541                                  struct ext2_inode *inode,
 542                                  void *buf, size_t size)
 543 {
 544         struct ext2_inode inode_buf;
 545         struct ext2_inline_data data;
 546         errcode_t retval;
 547         size_t free_ea_size, existing_size, free_inode_size;
 548
 549         if (!inode) {
 550                 retval = ext2fs_read_inode(fs, ino, &inode_buf);
 551                 if (retval)
 552                         return retval;
 553                 inode = &inode_buf;
 554         }
 555
 556         if (size <= EXT4_MIN_INLINE_DATA_SIZE) {
 557                 memcpy((void *)inode->i_block, buf, size);
 558                 return ext2fs_write_inode(fs, ino, inode);
 559         }
 560
 561         retval = ext2fs_xattr_inode_max_size(fs, ino, &free_ea_size);
 562         if (retval)
 563                 return retval;
 564
 565         retval = ext2fs_inline_data_size(fs, ino, &existing_size);
 566         if (retval)
 567                 return retval;
 568
 569         if (existing_size < EXT4_MIN_INLINE_DATA_SIZE)
 570                 free_inode_size = EXT4_MIN_INLINE_DATA_SIZE - existing_size;
 571         else
 572                 free_inode_size = 0;
 573
 574         if (size > existing_size + free_ea_size + free_inode_size)
 575                 return EXT2_ET_INLINE_DATA_NO_SPACE;
 576
 577         memcpy((void *)inode->i_block, buf, EXT4_MIN_INLINE_DATA_SIZE);
 578         retval = ext2fs_write_inode(fs, ino, inode);
 579         if (retval)
 580                 return retval;
 581         data.fs = fs;
 582         data.ino = ino;
 583         data.ea_size = size - EXT4_MIN_INLINE_DATA_SIZE;
 584         data.ea_data = buf + EXT4_MIN_INLINE_DATA_SIZE;
 585         return ext2fs_inline_data_ea_set(&data);
 586 }
 587
 588 #ifdef DEBUG
 589 #include "e2p/e2p.h"
 590
 591 /*
 592  * The length of buffer is set to 64 because in inode's i_block member it only
 593  * can save 60 bytes.  Thus this value can let the data being saved in extra
 594  * space.
 595  */
 596 #define BUFF_SIZE (64)
 597
 598 static errcode_t file_test(ext2_filsys fs)
 599 {
 600         struct ext2_inode inode;
 601         ext2_ino_t newfile;
 602         errcode_t retval;
 603         size_t size;
 604         char *buf = 0, *cmpbuf = 0;
 605         int i;
 606
 607         /* create a new file */
 608         retval = ext2fs_new_inode(fs, 2, 010755, 0, &newfile);
 609         if (retval) {
 610                 com_err("file_test", retval, "while allocaing a new inode");
 611                 return 1;
 612         }
 613
 614         memset(&inode, 0, sizeof(inode));
 615         inode.i_flags |= EXT4_INLINE_DATA_FL;
 616         inode.i_size = EXT4_MIN_INLINE_DATA_SIZE;
 617         inode.i_mode = LINUX_S_IFREG;
 618         retval = ext2fs_write_new_inode(fs, newfile, &inode);
 619         if (retval) {
 620                 com_err("file_test", retval, "while writting a new inode");
 621                 return 1;
 622         }
 623
 624         retval = ext2fs_inline_data_init(fs, newfile);
 625         if (retval) {
 626                 com_err("file_test", retval, "while init 'system.data'");
 627                 return 1;
 628         }
 629
 630         retval = ext2fs_inline_data_size(fs, newfile, &size);
 631         if (retval) {
 632                 com_err("file_test", retval, "while getting size");
 633                 return 1;
 634         }
 635
 636         if (size != EXT4_MIN_INLINE_DATA_SIZE) {
 637                 fprintf(stderr,
 638                         "tst_inline_data: size of inline data is wrong\n");
 639                 return 1;
 640         }
 641
 642         ext2fs_get_mem(BUFF_SIZE, &buf);
 643         memset(buf, 'a', BUFF_SIZE);
 644         retval = ext2fs_inline_data_set(fs, newfile, 0, buf, BUFF_SIZE);
 645         if (retval) {
 646                 com_err("file_test", retval,
 647                         "while setting inline data %s", buf);
 648                 goto err;
 649         }
 650
 651         ext2fs_get_mem(BUFF_SIZE, &cmpbuf);
 652         retval = ext2fs_inline_data_get(fs, newfile, 0, cmpbuf, &size);
 653         if (retval) {
 654                 com_err("file_test", retval, "while getting inline data");
 655                 goto err;
 656         }
 657
 658         if (size != BUFF_SIZE) {
 659                 fprintf(stderr,
 660                         "tst_inline_data: size %lu != buflen %lu\n",
 661                         size, BUFF_SIZE);
 662                 retval = 1;
 663                 goto err;
 664         }
 665
 666         if (memcmp(buf, cmpbuf, BUFF_SIZE)) {
 667                 fprintf(stderr, "tst_inline_data: buf != cmpbuf\n");
 668                 retval = 1;
 669                 goto err;
 670         }
 671
 672         retval = ext2fs_punch(fs, newfile, 0, 0, 0, ~0ULL);
 673         if (retval) {
 674                 com_err("file_test", retval, "while truncating inode");
 675                 goto err;
 676         }
 677
 678         /* reload inode and check isize */
 679         ext2fs_read_inode(fs, newfile, &inode);
 680         if (inode.i_size != 0) {
 681                 fprintf(stderr, "tst_inline_data: i_size should be 0\n");
 682                 retval = 1;
 683         }
 684
 685 err:
 686         if (cmpbuf)
 687                 ext2fs_free_mem(&cmpbuf);
 688         if (buf)
 689                 ext2fs_free_mem(&buf);
 690         return retval;
 691 }
 692
 693 static errcode_t dir_test(ext2_filsys fs)
 694 {
 695         const char *dot_name = ".";
 696         const char *stub_name = "stub";
 697         const char *parent_name = "test";
 698         ext2_ino_t parent, dir, tmp;
 699         errcode_t retval;
 700         char dirname[PATH_MAX];
 701         int i;
 702
 703         retval = ext2fs_mkdir(fs, 11, 11, stub_name);
 704         if (retval) {
 705                 com_err("dir_test", retval, "while creating %s dir", stub_name);
 706                 return retval;
 707         }
 708
 709         retval = ext2fs_mkdir(fs, 11, 0, parent_name);
 710         if (retval) {
 711                 com_err("dir_test", retval,
 712                         "while creating %s dir", parent_name);
 713                 return retval;
 714         }
 715
 716         retval = ext2fs_lookup(fs, 11, parent_name, strlen(parent_name),
 717                                0, &parent);
 718         if (retval) {
 719                 com_err("dir_test", retval,
 720                         "while looking up %s dir", parent_name);
 721                 return retval;
 722         }
 723
 724         retval = ext2fs_lookup(fs, parent, dot_name, strlen(dot_name),
 725                                0, &tmp);
 726         if (retval) {
 727                 com_err("dir_test", retval,
 728                         "while looking up %s dir", parent_name);
 729                 return retval;
 730         }
 731
 732         if (parent != tmp) {
 733                 fprintf(stderr, "tst_inline_data: parent (%lu) != tmp (%lu)\n",
 734                         parent, tmp);
 735                 return 1;
 736         }
 737
 738         for (i = 0, dir = 13; i < 4; i++, dir++) {
 739                 tmp = 0;
 740                 snprintf(dirname, PATH_MAX, "%d", i);
 741                 retval = ext2fs_mkdir(fs, parent, 0, dirname);
 742                 if (retval) {
 743                         com_err("dir_test", retval,
 744                                 "while creating %s dir", dirname);
 745                         return retval;
 746                 }
 747
 748                 retval = ext2fs_lookup(fs, parent, dirname, strlen(dirname),
 749                                        0, &tmp);
 750                 if (retval) {
 751                         com_err("dir_test", retval,
 752                                 "while looking up %s dir", parent_name);
 753                         return retval;
 754                 }
 755
 756                 if (dir != tmp) {
 757                         fprintf(stderr, "tst_inline_data: dir (%lu) != tmp (%lu)\n",
 758                                 dir, tmp);
 759                         return 1;
 760                 }
 761         }
 762
 763         snprintf(dirname, PATH_MAX, "%d", i);
 764         retval = ext2fs_mkdir(fs, parent, 0, dirname);
 765         if (retval && retval != EXT2_ET_DIR_NO_SPACE) {
 766                 com_err("dir_test", retval, "while creating %s dir", dirname);
 767                 return retval;
 768         }
 769
 770         retval = ext2fs_expand_dir(fs, parent);
 771         if (retval) {
 772                 com_err("dir_test", retval, "while expanding %s dir", parent_name);
 773                 return retval;
 774         }
 775
 776         return 0;
 777 }
 778
 779 int main(int argc, char *argv[])
 780 {
 781         ext2_filsys             fs;
 782         struct ext2_super_block param;
 783         errcode_t               retval;
 784         int                     i;
 785
 786         /* setup */
 787         initialize_ext2_error_table();
 788
 789         memset(&param, 0, sizeof(param));
 790         ext2fs_blocks_count_set(&param, 32768);
 791         param.s_inodes_count = 100;
 792
 793         param.s_feature_incompat |= EXT4_FEATURE_INCOMPAT_INLINE_DATA;
 794         param.s_rev_level = EXT2_DYNAMIC_REV;
 795         param.s_inode_size = 256;
 796
 797         retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, &param,
 798                                    test_io_manager, &fs);
 799         if (retval) {
 800                 com_err("setup", retval,
 801                         "while initializing filesystem");
 802                 exit(1);
 803         }
 804
 805         retval = ext2fs_allocate_tables(fs);
 806         if (retval) {
 807                 com_err("setup", retval,
 808                         "while allocating tables for test filesysmte");
 809                 exit(1);
 810         }
 811
 812         /* initialize inode cache */
 813         if (!fs->icache) {
 814                 struct ext2_inode inode;
 815                 ext2_ino_t first_ino = EXT2_FIRST_INO(fs->super);
 816                 int i;
 817
 818                 /* we just want to init inode cache.  So ignore error */
 819                 ext2fs_create_inode_cache(fs, 16);
 820                 if (!fs->icache) {
 821                         fprintf(stderr,
 822                                 "tst_inline_data: init inode cache failed\n");
 823                         exit(1);
 824                 }
 825
 826                 /* setup inode cache */
 827                 for (i = 0; i < fs->icache->cache_size; i++)
 828                         fs->icache->cache[i].ino = first_ino++;
 829         }
 830
 831         /* test */
 832         if (file_test(fs)) {
 833                 fprintf(stderr, "tst_inline_data(FILE): FAILED\n");
 834                 return 1;
 835         }
 836         printf("tst_inline_data(FILE): OK\n");
 837
 838         if (dir_test(fs)) {
 839                 fprintf(stderr, "tst_inline_data(DIR): FAILED\n");
 840                 return 1;
 841         }
 842         printf("tst_inline_data(DIR): OK\n");
 843
 844         return 0;
 845 }
 846 #endif