fs/ubifs/ubifs.c

   1 /*
   2  * This file is part of UBIFS.
   3  *
   4  * Copyright (C) 2006-2008 Nokia Corporation.
   5  *
   6  * (C) Copyright 2008-2010
   7  * Stefan Roese, DENX Software Engineering, sr@denx.de.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published by
  11  * the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along with
  19  * this program; if not, write to the Free Software Foundation, Inc., 51
  20  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  *
  22  * Authors: Artem Bityutskiy (Битюцкий Артём)
  23  *          Adrian Hunter
  24  */
  25
  26 #include "ubifs.h"
  27 #include <u-boot/zlib.h>
  28
  29 DECLARE_GLOBAL_DATA_PTR;
  30
  31 /* compress.c */
  32
  33 /*
  34  * We need a wrapper for zunzip() because the parameters are
  35  * incompatible with the lzo decompressor.
  36  */
  37 static int gzip_decompress(const unsigned char *in, size_t in_len,
  38                            unsigned char *out, size_t *out_len)
  39 {
  40         return zunzip(out, *out_len, (unsigned char *)in,
  41                       (unsigned long *)out_len, 0, 0);
  42 }
  43
  44 /* Fake description object for the "none" compressor */
  45 static struct ubifs_compressor none_compr = {
  46         .compr_type = UBIFS_COMPR_NONE,
  47         .name = "no compression",
  48         .capi_name = "",
  49         .decompress = NULL,
  50 };
  51
  52 static struct ubifs_compressor lzo_compr = {
  53         .compr_type = UBIFS_COMPR_LZO,
  54         .name = "LZO",
  55         .capi_name = "lzo",
  56         .decompress = lzo1x_decompress_safe,
  57 };
  58
  59 static struct ubifs_compressor zlib_compr = {
  60         .compr_type = UBIFS_COMPR_ZLIB,
  61         .name = "zlib",
  62         .capi_name = "deflate",
  63         .decompress = gzip_decompress,
  64 };
  65
  66 /* All UBIFS compressors */
  67 struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
  68
  69 /**
  70  * ubifs_decompress - decompress data.
  71  * @in_buf: data to decompress
  72  * @in_len: length of the data to decompress
  73  * @out_buf: output buffer where decompressed data should
  74  * @out_len: output length is returned here
  75  * @compr_type: type of compression
  76  *
  77  * This function decompresses data from buffer @in_buf into buffer @out_buf.
  78  * The length of the uncompressed data is returned in @out_len. This functions
  79  * returns %0 on success or a negative error code on failure.
  80  */
  81 int ubifs_decompress(const void *in_buf, int in_len, void *out_buf,
  82                      int *out_len, int compr_type)
  83 {
  84         int err;
  85         struct ubifs_compressor *compr;
  86
  87         if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
  88                 ubifs_err("invalid compression type %d", compr_type);
  89                 return -EINVAL;
  90         }
  91
  92         compr = ubifs_compressors[compr_type];
  93
  94         if (unlikely(!compr->capi_name)) {
  95                 ubifs_err("%s compression is not compiled in", compr->name);
  96                 return -EINVAL;
  97         }
  98
  99         if (compr_type == UBIFS_COMPR_NONE) {
 100                 memcpy(out_buf, in_buf, in_len);
 101                 *out_len = in_len;
 102                 return 0;
 103         }
 104
 105         err = compr->decompress(in_buf, in_len, out_buf, (size_t *)out_len);
 106         if (err)
 107                 ubifs_err("cannot decompress %d bytes, compressor %s, "
 108                           "error %d", in_len, compr->name, err);
 109
 110         return err;
 111 }
 112
 113 /**
 114  * compr_init - initialize a compressor.
 115  * @compr: compressor description object
 116  *
 117  * This function initializes the requested compressor and returns zero in case
 118  * of success or a negative error code in case of failure.
 119  */
 120 static int __init compr_init(struct ubifs_compressor *compr)
 121 {
 122         ubifs_compressors[compr->compr_type] = compr;
 123
 124 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 125         ubifs_compressors[compr->compr_type]->name += gd->reloc_off;
 126         ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off;
 127         ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off;
 128 #endif
 129
 130         return 0;
 131 }
 132
 133 /**
 134  * ubifs_compressors_init - initialize UBIFS compressors.
 135  *
 136  * This function initializes the compressor which were compiled in. Returns
 137  * zero in case of success and a negative error code in case of failure.
 138  */
 139 int __init ubifs_compressors_init(void)
 140 {
 141         int err;
 142
 143         err = compr_init(&lzo_compr);
 144         if (err)
 145                 return err;
 146
 147         err = compr_init(&zlib_compr);
 148         if (err)
 149                 return err;
 150
 151         err = compr_init(&none_compr);
 152         if (err)
 153                 return err;
 154
 155         return 0;
 156 }
 157
 158 /*
 159  * ubifsls...
 160  */
 161
 162 static int filldir(struct ubifs_info *c, const char *name, int namlen,
 163                    u64 ino, unsigned int d_type)
 164 {
 165         struct inode *inode;
 166         char filetime[32];
 167
 168         switch (d_type) {
 169         case UBIFS_ITYPE_REG:
 170                 printf("\t");
 171                 break;
 172         case UBIFS_ITYPE_DIR:
 173                 printf("<DIR>\t");
 174                 break;
 175         case UBIFS_ITYPE_LNK:
 176                 printf("<LNK>\t");
 177                 break;
 178         default:
 179                 printf("other\t");
 180                 break;
 181         }
 182
 183         inode = ubifs_iget(c->vfs_sb, ino);
 184         if (IS_ERR(inode)) {
 185                 printf("%s: Error in ubifs_iget(), ino=%lld ret=%p!\n",
 186                        __func__, ino, inode);
 187                 return -1;
 188         }
 189         ctime_r((time_t *)&inode->i_mtime, filetime);
 190         printf("%9lld  %24.24s  ", inode->i_size, filetime);
 191         ubifs_iput(inode);
 192
 193         printf("%s\n", name);
 194
 195         return 0;
 196 }
 197
 198 static int ubifs_printdir(struct file *file, void *dirent)
 199 {
 200         int err, over = 0;
 201         struct qstr nm;
 202         union ubifs_key key;
 203         struct ubifs_dent_node *dent;
 204         struct inode *dir = file->f_path.dentry->d_inode;
 205         struct ubifs_info *c = dir->i_sb->s_fs_info;
 206
 207         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
 208
 209         if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)
 210                 /*
 211                  * The directory was seek'ed to a senseless position or there
 212                  * are no more entries.
 213                  */
 214                 return 0;
 215
 216         if (file->f_pos == 1) {
 217                 /* Find the first entry in TNC and save it */
 218                 lowest_dent_key(c, &key, dir->i_ino);
 219                 nm.name = NULL;
 220                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 221                 if (IS_ERR(dent)) {
 222                         err = PTR_ERR(dent);
 223                         goto out;
 224                 }
 225
 226                 file->f_pos = key_hash_flash(c, &dent->key);
 227                 file->private_data = dent;
 228         }
 229
 230         dent = file->private_data;
 231         if (!dent) {
 232                 /*
 233                  * The directory was seek'ed to and is now readdir'ed.
 234                  * Find the entry corresponding to @file->f_pos or the
 235                  * closest one.
 236                  */
 237                 dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);
 238                 nm.name = NULL;
 239                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 240                 if (IS_ERR(dent)) {
 241                         err = PTR_ERR(dent);
 242                         goto out;
 243                 }
 244                 file->f_pos = key_hash_flash(c, &dent->key);
 245                 file->private_data = dent;
 246         }
 247
 248         while (1) {
 249                 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
 250                         dent->name, (unsigned long long)le64_to_cpu(dent->inum),
 251                         key_hash_flash(c, &dent->key));
 252                 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
 253
 254                 nm.len = le16_to_cpu(dent->nlen);
 255                 over = filldir(c, (char *)dent->name, nm.len,
 256                                le64_to_cpu(dent->inum), dent->type);
 257                 if (over)
 258                         return 0;
 259
 260                 /* Switch to the next entry */
 261                 key_read(c, &dent->key, &key);
 262                 nm.name = (char *)dent->name;
 263                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 264                 if (IS_ERR(dent)) {
 265                         err = PTR_ERR(dent);
 266                         goto out;
 267                 }
 268
 269                 kfree(file->private_data);
 270                 file->f_pos = key_hash_flash(c, &dent->key);
 271                 file->private_data = dent;
 272                 cond_resched();
 273         }
 274
 275 out:
 276         if (err != -ENOENT) {
 277                 ubifs_err("cannot find next direntry, error %d", err);
 278                 return err;
 279         }
 280
 281         kfree(file->private_data);
 282         file->private_data = NULL;
 283         file->f_pos = 2;
 284         return 0;
 285 }
 286
 287 static int ubifs_finddir(struct super_block *sb, char *dirname,
 288                          unsigned long root_inum, unsigned long *inum)
 289 {
 290         int err;
 291         struct qstr nm;
 292         union ubifs_key key;
 293         struct ubifs_dent_node *dent;
 294         struct ubifs_info *c;
 295         struct file *file;
 296         struct dentry *dentry;
 297         struct inode *dir;
 298         int ret = 0;
 299
 300         file = kzalloc(sizeof(struct file), 0);
 301         dentry = kzalloc(sizeof(struct dentry), 0);
 302         dir = kzalloc(sizeof(struct inode), 0);
 303         if (!file || !dentry || !dir) {
 304                 printf("%s: Error, no memory for malloc!\n", __func__);
 305                 err = -ENOMEM;
 306                 goto out;
 307         }
 308
 309         dir->i_sb = sb;
 310         file->f_path.dentry = dentry;
 311         file->f_path.dentry->d_parent = dentry;
 312         file->f_path.dentry->d_inode = dir;
 313         file->f_path.dentry->d_inode->i_ino = root_inum;
 314         c = sb->s_fs_info;
 315
 316         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
 317
 318         /* Find the first entry in TNC and save it */
 319         lowest_dent_key(c, &key, dir->i_ino);
 320         nm.name = NULL;
 321         dent = ubifs_tnc_next_ent(c, &key, &nm);
 322         if (IS_ERR(dent)) {
 323                 err = PTR_ERR(dent);
 324                 goto out;
 325         }
 326
 327         file->f_pos = key_hash_flash(c, &dent->key);
 328         file->private_data = dent;
 329
 330         while (1) {
 331                 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
 332                         dent->name, (unsigned long long)le64_to_cpu(dent->inum),
 333                         key_hash_flash(c, &dent->key));
 334                 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
 335
 336                 nm.len = le16_to_cpu(dent->nlen);
 337                 if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
 338                     (strlen(dirname) == nm.len)) {
 339                         *inum = le64_to_cpu(dent->inum);
 340                         ret = 1;
 341                         goto out_free;
 342                 }
 343
 344                 /* Switch to the next entry */
 345                 key_read(c, &dent->key, &key);
 346                 nm.name = (char *)dent->name;
 347                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 348                 if (IS_ERR(dent)) {
 349                         err = PTR_ERR(dent);
 350                         goto out;
 351                 }
 352
 353                 kfree(file->private_data);
 354                 file->f_pos = key_hash_flash(c, &dent->key);
 355                 file->private_data = dent;
 356                 cond_resched();
 357         }
 358
 359 out:
 360         if (err != -ENOENT)
 361                 ubifs_err("cannot find next direntry, error %d", err);
 362
 363 out_free:
 364         if (file->private_data)
 365                 kfree(file->private_data);
 366         if (file)
 367                 free(file);
 368         if (dentry)
 369                 free(dentry);
 370         if (dir)
 371                 free(dir);
 372
 373         return ret;
 374 }
 375
 376 static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
 377 {
 378         int ret;
 379         char *next;
 380         char fpath[128];
 381         char symlinkpath[128];
 382         char *name = fpath;
 383         unsigned long root_inum = 1;
 384         unsigned long inum;
 385         int symlink_count = 0; /* Don't allow symlink recursion */
 386         char link_name[64];
 387
 388         strcpy(fpath, filename);
 389
 390         /* Remove all leading slashes */
 391         while (*name == '/')
 392                 name++;
 393
 394         /*
 395          * Handle root-direcoty ('/')
 396          */
 397         inum = root_inum;
 398         if (!name || *name == '\0')
 399                 return inum;
 400
 401         for (;;) {
 402                 struct inode *inode;
 403                 struct ubifs_inode *ui;
 404
 405                 /* Extract the actual part from the pathname.  */
 406                 next = strchr(name, '/');
 407                 if (next) {
 408                         /* Remove all leading slashes.  */
 409                         while (*next == '/')
 410                                 *(next++) = '\0';
 411                 }
 412
 413                 ret = ubifs_finddir(sb, name, root_inum, &inum);
 414                 if (!ret)
 415                         return 0;
 416                 inode = ubifs_iget(sb, inum);
 417
 418                 if (!inode)
 419                         return 0;
 420                 ui = ubifs_inode(inode);
 421
 422                 if ((inode->i_mode & S_IFMT) == S_IFLNK) {
 423                         char buf[128];
 424
 425                         /* We have some sort of symlink recursion, bail out */
 426                         if (symlink_count++ > 8) {
 427                                 printf("Symlink recursion, aborting\n");
 428                                 return 0;
 429                         }
 430                         memcpy(link_name, ui->data, ui->data_len);
 431                         link_name[ui->data_len] = '\0';
 432
 433                         if (link_name[0] == '/') {
 434                                 /* Absolute path, redo everything without
 435                                  * the leading slash */
 436                                 next = name = link_name + 1;
 437                                 root_inum = 1;
 438                                 continue;
 439                         }
 440                         /* Relative to cur dir */
 441                         sprintf(buf, "%s/%s",
 442                                         link_name, next == NULL ? "" : next);
 443                         memcpy(symlinkpath, buf, sizeof(buf));
 444                         next = name = symlinkpath;
 445                         continue;
 446                 }
 447
 448                 /*
 449                  * Check if directory with this name exists
 450                  */
 451
 452                 /* Found the node!  */
 453                 if (!next || *next == '\0')
 454                         return inum;
 455
 456                 root_inum = inum;
 457                 name = next;
 458         }
 459
 460         return 0;
 461 }
 462
 463 int ubifs_ls(char *filename)
 464 {
 465         struct ubifs_info *c = ubifs_sb->s_fs_info;
 466         struct file *file;
 467         struct dentry *dentry;
 468         struct inode *dir;
 469         void *dirent = NULL;
 470         unsigned long inum;
 471         int ret = 0;
 472
 473         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
 474         inum = ubifs_findfile(ubifs_sb, filename);
 475         if (!inum) {
 476                 ret = -1;
 477                 goto out;
 478         }
 479
 480         file = kzalloc(sizeof(struct file), 0);
 481         dentry = kzalloc(sizeof(struct dentry), 0);
 482         dir = kzalloc(sizeof(struct inode), 0);
 483         if (!file || !dentry || !dir) {
 484                 printf("%s: Error, no memory for malloc!\n", __func__);
 485                 ret = -ENOMEM;
 486                 goto out_mem;
 487         }
 488
 489         dir->i_sb = ubifs_sb;
 490         file->f_path.dentry = dentry;
 491         file->f_path.dentry->d_parent = dentry;
 492         file->f_path.dentry->d_inode = dir;
 493         file->f_path.dentry->d_inode->i_ino = inum;
 494         file->f_pos = 1;
 495         file->private_data = NULL;
 496         ubifs_printdir(file, dirent);
 497
 498 out_mem:
 499         if (file)
 500                 free(file);
 501         if (dentry)
 502                 free(dentry);
 503         if (dir)
 504                 free(dir);
 505
 506 out:
 507         ubi_close_volume(c->ubi);
 508         return ret;
 509 }
 510
 511 /*
 512  * ubifsload...
 513  */
 514
 515 /* file.c */
 516
 517 static inline void *kmap(struct page *page)
 518 {
 519         return page->addr;
 520 }
 521
 522 static int read_block(struct inode *inode, void *addr, unsigned int block,
 523                       struct ubifs_data_node *dn)
 524 {
 525         struct ubifs_info *c = inode->i_sb->s_fs_info;
 526         int err, len, out_len;
 527         union ubifs_key key;
 528         unsigned int dlen;
 529
 530         data_key_init(c, &key, inode->i_ino, block);
 531         err = ubifs_tnc_lookup(c, &key, dn);
 532         if (err) {
 533                 if (err == -ENOENT)
 534                         /* Not found, so it must be a hole */
 535                         memset(addr, 0, UBIFS_BLOCK_SIZE);
 536                 return err;
 537         }
 538
 539         ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
 540
 541         len = le32_to_cpu(dn->size);
 542         if (len <= 0 || len > UBIFS_BLOCK_SIZE)
 543                 goto dump;
 544
 545         dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
 546         out_len = UBIFS_BLOCK_SIZE;
 547         err = ubifs_decompress(&dn->data, dlen, addr, &out_len,
 548                                le16_to_cpu(dn->compr_type));
 549         if (err || len != out_len)
 550                 goto dump;
 551
 552         /*
 553          * Data length can be less than a full block, even for blocks that are
 554          * not the last in the file (e.g., as a result of making a hole and
 555          * appending data). Ensure that the remainder is zeroed out.
 556          */
 557         if (len < UBIFS_BLOCK_SIZE)
 558                 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
 559
 560         return 0;
 561
 562 dump:
 563         ubifs_err("bad data node (block %u, inode %lu)",
 564                   block, inode->i_ino);
 565         dbg_dump_node(c, dn);
 566         return -EINVAL;
 567 }
 568
 569 static int do_readpage(struct ubifs_info *c, struct inode *inode,
 570                        struct page *page, int last_block_size)
 571 {
 572         void *addr;
 573         int err = 0, i;
 574         unsigned int block, beyond;
 575         struct ubifs_data_node *dn;
 576         loff_t i_size = inode->i_size;
 577
 578         dbg_gen("ino %lu, pg %lu, i_size %lld",
 579                 inode->i_ino, page->index, i_size);
 580
 581         addr = kmap(page);
 582
 583         block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
 584         beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
 585         if (block >= beyond) {
 586                 /* Reading beyond inode */
 587                 memset(addr, 0, PAGE_CACHE_SIZE);
 588                 goto out;
 589         }
 590
 591         dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
 592         if (!dn)
 593                 return -ENOMEM;
 594
 595         i = 0;
 596         while (1) {
 597                 int ret;
 598
 599                 if (block >= beyond) {
 600                         /* Reading beyond inode */
 601                         err = -ENOENT;
 602                         memset(addr, 0, UBIFS_BLOCK_SIZE);
 603                 } else {
 604                         /*
 605                          * Reading last block? Make sure to not write beyond
 606                          * the requested size in the destination buffer.
 607                          */
 608                         if (((block + 1) == beyond) || last_block_size) {
 609                                 void *buff;
 610                                 int dlen;
 611
 612                                 /*
 613                                  * We need to buffer the data locally for the
 614                                  * last block. This is to not pad the
 615                                  * destination area to a multiple of
 616                                  * UBIFS_BLOCK_SIZE.
 617                                  */
 618                                 buff = malloc(UBIFS_BLOCK_SIZE);
 619                                 if (!buff) {
 620                                         printf("%s: Error, malloc fails!\n",
 621                                                __func__);
 622                                         err = -ENOMEM;
 623                                         break;
 624                                 }
 625
 626                                 /* Read block-size into temp buffer */
 627                                 ret = read_block(inode, buff, block, dn);
 628                                 if (ret) {
 629                                         err = ret;
 630                                         if (err != -ENOENT) {
 631                                                 free(buff);
 632                                                 break;
 633                                         }
 634                                 }
 635
 636                                 if (last_block_size)
 637                                         dlen = last_block_size;
 638                                 else
 639                                         dlen = le32_to_cpu(dn->size);
 640
 641                                 /* Now copy required size back to dest */
 642                                 memcpy(addr, buff, dlen);
 643
 644                                 free(buff);
 645                         } else {
 646                                 ret = read_block(inode, addr, block, dn);
 647                                 if (ret) {
 648                                         err = ret;
 649                                         if (err != -ENOENT)
 650                                                 break;
 651                                 }
 652                         }
 653                 }
 654                 if (++i >= UBIFS_BLOCKS_PER_PAGE)
 655                         break;
 656                 block += 1;
 657                 addr += UBIFS_BLOCK_SIZE;
 658         }
 659         if (err) {
 660                 if (err == -ENOENT) {
 661                         /* Not found, so it must be a hole */
 662                         dbg_gen("hole");
 663                         goto out_free;
 664                 }
 665                 ubifs_err("cannot read page %lu of inode %lu, error %d",
 666                           page->index, inode->i_ino, err);
 667                 goto error;
 668         }
 669
 670 out_free:
 671         kfree(dn);
 672 out:
 673         return 0;
 674
 675 error:
 676         kfree(dn);
 677         return err;
 678 }
 679
 680 int ubifs_load(char *filename, u32 addr, u32 size)
 681 {
 682         struct ubifs_info *c = ubifs_sb->s_fs_info;
 683         unsigned long inum;
 684         struct inode *inode;
 685         struct page page;
 686         int err = 0;
 687         int i;
 688         int count;
 689         int last_block_size = 0;
 690         char buf [10];
 691
 692         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
 693         /* ubifs_findfile will resolve symlinks, so we know that we get
 694          * the real file here */
 695         inum = ubifs_findfile(ubifs_sb, filename);
 696         if (!inum) {
 697                 err = -1;
 698                 goto out;
 699         }
 700
 701         /*
 702          * Read file inode
 703          */
 704         inode = ubifs_iget(ubifs_sb, inum);
 705         if (IS_ERR(inode)) {
 706                 printf("%s: Error reading inode %ld!\n", __func__, inum);
 707                 err = PTR_ERR(inode);
 708                 goto out;
 709         }
 710
 711         /*
 712          * If no size was specified or if size bigger than filesize
 713          * set size to filesize
 714          */
 715         if ((size == 0) || (size > inode->i_size))
 716                 size = inode->i_size;
 717
 718         count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
 719         printf("Loading file '%s' to addr 0x%08x with size %d (0x%08x)...\n",
 720                filename, addr, size, size);
 721
 722         page.addr = (void *)addr;
 723         page.index = 0;
 724         page.inode = inode;
 725         for (i = 0; i < count; i++) {
 726                 /*
 727                  * Make sure to not read beyond the requested size
 728                  */
 729                 if (((i + 1) == count) && (size < inode->i_size))
 730                         last_block_size = size - (i * PAGE_SIZE);
 731
 732                 err = do_readpage(c, inode, &page, last_block_size);
 733                 if (err)
 734                         break;
 735
 736                 page.addr += PAGE_SIZE;
 737                 page.index++;
 738         }
 739
 740         if (err)
 741                 printf("Error reading file '%s'\n", filename);
 742         else {
 743                 sprintf(buf, "%X", size);
 744                 setenv("filesize", buf);
 745                 printf("Done\n");
 746         }
 747
 748         ubifs_iput(inode);
 749
 750 out:
 751         ubi_close_volume(c->ubi);
 752         return err;
 753 }