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