fs/ubifs/ubifs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * This file is part of UBIFS.
   4  *
   5  * Copyright (C) 2006-2008 Nokia Corporation.
   6  *
   7  * (C) Copyright 2008-2010
   8  * Stefan Roese, DENX Software Engineering, sr@denx.de.
   9  *
  10  * Authors: Artem Bityutskiy (Битюцкий Артём)
  11  *          Adrian Hunter
  12  */
  13
  14 #include <common.h>
  15 #include <memalign.h>
  16 #include "ubifs.h"
  17 #include <u-boot/zlib.h>
  18
  19 #include <linux/err.h>
  20 #include <linux/lzo.h>
  21
  22 DECLARE_GLOBAL_DATA_PTR;
  23
  24 /* compress.c */
  25
  26 /*
  27  * We need a wrapper for zunzip() because the parameters are
  28  * incompatible with the lzo decompressor.
  29  */
  30 static int gzip_decompress(const unsigned char *in, size_t in_len,
  31                            unsigned char *out, size_t *out_len)
  32 {
  33         return zunzip(out, *out_len, (unsigned char *)in,
  34                       (unsigned long *)out_len, 0, 0);
  35 }
  36
  37 /* Fake description object for the "none" compressor */
  38 static struct ubifs_compressor none_compr = {
  39         .compr_type = UBIFS_COMPR_NONE,
  40         .name = "none",
  41         .capi_name = "",
  42         .decompress = NULL,
  43 };
  44
  45 static struct ubifs_compressor lzo_compr = {
  46         .compr_type = UBIFS_COMPR_LZO,
  47 #ifndef __UBOOT__
  48         .comp_mutex = &lzo_mutex,
  49 #endif
  50         .name = "lzo",
  51         .capi_name = "lzo",
  52         .decompress = lzo1x_decompress_safe,
  53 };
  54
  55 static struct ubifs_compressor zlib_compr = {
  56         .compr_type = UBIFS_COMPR_ZLIB,
  57 #ifndef __UBOOT__
  58         .comp_mutex = &deflate_mutex,
  59         .decomp_mutex = &inflate_mutex,
  60 #endif
  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 #ifdef __UBOOT__
  71 /* from mm/util.c */
  72
  73 /**
  74  * kmemdup - duplicate region of memory
  75  *
  76  * @src: memory region to duplicate
  77  * @len: memory region length
  78  * @gfp: GFP mask to use
  79  */
  80 void *kmemdup(const void *src, size_t len, gfp_t gfp)
  81 {
  82         void *p;
  83
  84         p = kmalloc(len, gfp);
  85         if (p)
  86                 memcpy(p, src, len);
  87         return p;
  88 }
  89
  90 struct crypto_comp {
  91         int compressor;
  92 };
  93
  94 static inline struct crypto_comp
  95 *crypto_alloc_comp(const char *alg_name, u32 type, u32 mask)
  96 {
  97         struct ubifs_compressor *comp;
  98         struct crypto_comp *ptr;
  99         int i = 0;
 100
 101         ptr = malloc_cache_aligned(sizeof(struct crypto_comp));
 102         while (i < UBIFS_COMPR_TYPES_CNT) {
 103                 comp = ubifs_compressors[i];
 104                 if (!comp) {
 105                         i++;
 106                         continue;
 107                 }
 108                 if (strncmp(alg_name, comp->capi_name, strlen(alg_name)) == 0) {
 109                         ptr->compressor = i;
 110                         return ptr;
 111                 }
 112                 i++;
 113         }
 114         if (i >= UBIFS_COMPR_TYPES_CNT) {
 115                 dbg_gen("invalid compression type %s", alg_name);
 116                 free (ptr);
 117                 return NULL;
 118         }
 119         return ptr;
 120 }
 121 static inline int
 122 crypto_comp_decompress(const struct ubifs_info *c, struct crypto_comp *tfm,
 123                        const u8 *src, unsigned int slen, u8 *dst,
 124                        unsigned int *dlen)
 125 {
 126         struct ubifs_compressor *compr = ubifs_compressors[tfm->compressor];
 127         int err;
 128         size_t tmp_len = *dlen;
 129
 130         if (compr->compr_type == UBIFS_COMPR_NONE) {
 131                 memcpy(dst, src, slen);
 132                 *dlen = slen;
 133                 return 0;
 134         }
 135
 136         err = compr->decompress(src, slen, dst, &tmp_len);
 137         if (err)
 138                 ubifs_err(c, "cannot decompress %d bytes, compressor %s, "
 139                           "error %d", slen, compr->name, err);
 140
 141         *dlen = tmp_len;
 142         return err;
 143
 144         return 0;
 145 }
 146
 147 /* from shrinker.c */
 148
 149 /* Global clean znode counter (for all mounted UBIFS instances) */
 150 atomic_long_t ubifs_clean_zn_cnt;
 151
 152 #endif
 153
 154 /**
 155  * ubifs_decompress - decompress data.
 156  * @in_buf: data to decompress
 157  * @in_len: length of the data to decompress
 158  * @out_buf: output buffer where decompressed data should
 159  * @out_len: output length is returned here
 160  * @compr_type: type of compression
 161  *
 162  * This function decompresses data from buffer @in_buf into buffer @out_buf.
 163  * The length of the uncompressed data is returned in @out_len. This functions
 164  * returns %0 on success or a negative error code on failure.
 165  */
 166 int ubifs_decompress(const struct ubifs_info *c, const void *in_buf,
 167                      int in_len, void *out_buf, int *out_len, int compr_type)
 168 {
 169         int err;
 170         struct ubifs_compressor *compr;
 171
 172         if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
 173                 ubifs_err(c, "invalid compression type %d", compr_type);
 174                 return -EINVAL;
 175         }
 176
 177         compr = ubifs_compressors[compr_type];
 178
 179         if (unlikely(!compr->capi_name)) {
 180                 ubifs_err(c, "%s compression is not compiled in", compr->name);
 181                 return -EINVAL;
 182         }
 183
 184         if (compr_type == UBIFS_COMPR_NONE) {
 185                 memcpy(out_buf, in_buf, in_len);
 186                 *out_len = in_len;
 187                 return 0;
 188         }
 189
 190         if (compr->decomp_mutex)
 191                 mutex_lock(compr->decomp_mutex);
 192         err = crypto_comp_decompress(c, compr->cc, in_buf, in_len, out_buf,
 193                                      (unsigned int *)out_len);
 194         if (compr->decomp_mutex)
 195                 mutex_unlock(compr->decomp_mutex);
 196         if (err)
 197                 ubifs_err(c, "cannot decompress %d bytes, compressor %s,"
 198                           " error %d", in_len, compr->name, err);
 199
 200         return err;
 201 }
 202
 203 /**
 204  * compr_init - initialize a compressor.
 205  * @compr: compressor description object
 206  *
 207  * This function initializes the requested compressor and returns zero in case
 208  * of success or a negative error code in case of failure.
 209  */
 210 static int __init compr_init(struct ubifs_compressor *compr)
 211 {
 212         ubifs_compressors[compr->compr_type] = compr;
 213
 214 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 215         ubifs_compressors[compr->compr_type]->name += gd->reloc_off;
 216         ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off;
 217         ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off;
 218 #endif
 219
 220         if (compr->capi_name) {
 221                 compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0);
 222                 if (IS_ERR(compr->cc)) {
 223                         dbg_gen("cannot initialize compressor %s,"
 224                                   " error %ld", compr->name,
 225                                   PTR_ERR(compr->cc));
 226                         return PTR_ERR(compr->cc);
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 /**
 234  * ubifs_compressors_init - initialize UBIFS compressors.
 235  *
 236  * This function initializes the compressor which were compiled in. Returns
 237  * zero in case of success and a negative error code in case of failure.
 238  */
 239 int __init ubifs_compressors_init(void)
 240 {
 241         int err;
 242
 243         err = compr_init(&lzo_compr);
 244         if (err)
 245                 return err;
 246
 247         err = compr_init(&zlib_compr);
 248         if (err)
 249                 return err;
 250
 251         err = compr_init(&none_compr);
 252         if (err)
 253                 return err;
 254
 255         return 0;
 256 }
 257
 258 /*
 259  * ubifsls...
 260  */
 261
 262 static int filldir(struct ubifs_info *c, const char *name, int namlen,
 263                    u64 ino, unsigned int d_type)
 264 {
 265         struct inode *inode;
 266         char filetime[32];
 267
 268         switch (d_type) {
 269         case UBIFS_ITYPE_REG:
 270                 printf("\t");
 271                 break;
 272         case UBIFS_ITYPE_DIR:
 273                 printf("<DIR>\t");
 274                 break;
 275         case UBIFS_ITYPE_LNK:
 276                 printf("<LNK>\t");
 277                 break;
 278         default:
 279                 printf("other\t");
 280                 break;
 281         }
 282
 283         inode = ubifs_iget(c->vfs_sb, ino);
 284         if (IS_ERR(inode)) {
 285                 printf("%s: Error in ubifs_iget(), ino=%lld ret=%p!\n",
 286                        __func__, ino, inode);
 287                 return -1;
 288         }
 289         ctime_r((time_t *)&inode->i_mtime, filetime);
 290         printf("%9lld  %24.24s  ", inode->i_size, filetime);
 291 #ifndef __UBOOT__
 292         ubifs_iput(inode);
 293 #endif
 294
 295         printf("%s\n", name);
 296
 297         return 0;
 298 }
 299
 300 static int ubifs_printdir(struct file *file, void *dirent)
 301 {
 302         int err, over = 0;
 303         struct qstr nm;
 304         union ubifs_key key;
 305         struct ubifs_dent_node *dent;
 306         struct inode *dir = file->f_path.dentry->d_inode;
 307         struct ubifs_info *c = dir->i_sb->s_fs_info;
 308
 309         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
 310
 311         if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)
 312                 /*
 313                  * The directory was seek'ed to a senseless position or there
 314                  * are no more entries.
 315                  */
 316                 return 0;
 317
 318         if (file->f_pos == 1) {
 319                 /* Find the first entry in TNC and save it */
 320                 lowest_dent_key(c, &key, dir->i_ino);
 321                 nm.name = NULL;
 322                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 323                 if (IS_ERR(dent)) {
 324                         err = PTR_ERR(dent);
 325                         goto out;
 326                 }
 327
 328                 file->f_pos = key_hash_flash(c, &dent->key);
 329                 file->private_data = dent;
 330         }
 331
 332         dent = file->private_data;
 333         if (!dent) {
 334                 /*
 335                  * The directory was seek'ed to and is now readdir'ed.
 336                  * Find the entry corresponding to @file->f_pos or the
 337                  * closest one.
 338                  */
 339                 dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);
 340                 nm.name = NULL;
 341                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 342                 if (IS_ERR(dent)) {
 343                         err = PTR_ERR(dent);
 344                         goto out;
 345                 }
 346                 file->f_pos = key_hash_flash(c, &dent->key);
 347                 file->private_data = dent;
 348         }
 349
 350         while (1) {
 351                 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
 352                         dent->name, (unsigned long long)le64_to_cpu(dent->inum),
 353                         key_hash_flash(c, &dent->key));
 354 #ifndef __UBOOT__
 355                 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
 356 #endif
 357
 358                 nm.len = le16_to_cpu(dent->nlen);
 359                 over = filldir(c, (char *)dent->name, nm.len,
 360                                le64_to_cpu(dent->inum), dent->type);
 361                 if (over)
 362                         return 0;
 363
 364                 /* Switch to the next entry */
 365                 key_read(c, &dent->key, &key);
 366                 nm.name = (char *)dent->name;
 367                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 368                 if (IS_ERR(dent)) {
 369                         err = PTR_ERR(dent);
 370                         goto out;
 371                 }
 372
 373                 kfree(file->private_data);
 374                 file->f_pos = key_hash_flash(c, &dent->key);
 375                 file->private_data = dent;
 376                 cond_resched();
 377         }
 378
 379 out:
 380         if (err != -ENOENT) {
 381                 ubifs_err(c, "cannot find next direntry, error %d", err);
 382                 return err;
 383         }
 384
 385         kfree(file->private_data);
 386         file->private_data = NULL;
 387         file->f_pos = 2;
 388         return 0;
 389 }
 390
 391 static int ubifs_finddir(struct super_block *sb, char *dirname,
 392                          unsigned long root_inum, unsigned long *inum)
 393 {
 394         int err;
 395         struct qstr nm;
 396         union ubifs_key key;
 397         struct ubifs_dent_node *dent;
 398         struct ubifs_info *c;
 399         struct file *file;
 400         struct dentry *dentry;
 401         struct inode *dir;
 402         int ret = 0;
 403
 404         file = kzalloc(sizeof(struct file), 0);
 405         dentry = kzalloc(sizeof(struct dentry), 0);
 406         dir = kzalloc(sizeof(struct inode), 0);
 407         if (!file || !dentry || !dir) {
 408                 printf("%s: Error, no memory for malloc!\n", __func__);
 409                 err = -ENOMEM;
 410                 goto out;
 411         }
 412
 413         dir->i_sb = sb;
 414         file->f_path.dentry = dentry;
 415         file->f_path.dentry->d_parent = dentry;
 416         file->f_path.dentry->d_inode = dir;
 417         file->f_path.dentry->d_inode->i_ino = root_inum;
 418         c = sb->s_fs_info;
 419
 420         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
 421
 422         /* Find the first entry in TNC and save it */
 423         lowest_dent_key(c, &key, dir->i_ino);
 424         nm.name = NULL;
 425         dent = ubifs_tnc_next_ent(c, &key, &nm);
 426         if (IS_ERR(dent)) {
 427                 err = PTR_ERR(dent);
 428                 goto out;
 429         }
 430
 431         file->f_pos = key_hash_flash(c, &dent->key);
 432         file->private_data = dent;
 433
 434         while (1) {
 435                 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
 436                         dent->name, (unsigned long long)le64_to_cpu(dent->inum),
 437                         key_hash_flash(c, &dent->key));
 438 #ifndef __UBOOT__
 439                 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
 440 #endif
 441
 442                 nm.len = le16_to_cpu(dent->nlen);
 443                 if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
 444                     (strlen(dirname) == nm.len)) {
 445                         *inum = le64_to_cpu(dent->inum);
 446                         ret = 1;
 447                         goto out_free;
 448                 }
 449
 450                 /* Switch to the next entry */
 451                 key_read(c, &dent->key, &key);
 452                 nm.name = (char *)dent->name;
 453                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 454                 if (IS_ERR(dent)) {
 455                         err = PTR_ERR(dent);
 456                         goto out;
 457                 }
 458
 459                 kfree(file->private_data);
 460                 file->f_pos = key_hash_flash(c, &dent->key);
 461                 file->private_data = dent;
 462                 cond_resched();
 463         }
 464
 465 out:
 466         if (err != -ENOENT)
 467                 dbg_gen("cannot find next direntry, error %d", err);
 468
 469 out_free:
 470         kfree(file->private_data);
 471         free(file);
 472         free(dentry);
 473         free(dir);
 474
 475         return ret;
 476 }
 477
 478 static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
 479 {
 480         int ret;
 481         char *next;
 482         char fpath[128];
 483         char symlinkpath[128];
 484         char *name = fpath;
 485         unsigned long root_inum = 1;
 486         unsigned long inum;
 487         int symlink_count = 0; /* Don't allow symlink recursion */
 488         char link_name[64];
 489
 490         strcpy(fpath, filename);
 491
 492         /* Remove all leading slashes */
 493         while (*name == '/')
 494                 name++;
 495
 496         /*
 497          * Handle root-direcoty ('/')
 498          */
 499         inum = root_inum;
 500         if (!name || *name == '\0')
 501                 return inum;
 502
 503         for (;;) {
 504                 struct inode *inode;
 505                 struct ubifs_inode *ui;
 506
 507                 /* Extract the actual part from the pathname.  */
 508                 next = strchr(name, '/');
 509                 if (next) {
 510                         /* Remove all leading slashes.  */
 511                         while (*next == '/')
 512                                 *(next++) = '\0';
 513                 }
 514
 515                 ret = ubifs_finddir(sb, name, root_inum, &inum);
 516                 if (!ret)
 517                         return 0;
 518                 inode = ubifs_iget(sb, inum);
 519
 520                 if (!inode)
 521                         return 0;
 522                 ui = ubifs_inode(inode);
 523
 524                 if ((inode->i_mode & S_IFMT) == S_IFLNK) {
 525                         char buf[128];
 526
 527                         /* We have some sort of symlink recursion, bail out */
 528                         if (symlink_count++ > 8) {
 529                                 printf("Symlink recursion, aborting\n");
 530                                 return 0;
 531                         }
 532                         memcpy(link_name, ui->data, ui->data_len);
 533                         link_name[ui->data_len] = '\0';
 534
 535                         if (link_name[0] == '/') {
 536                                 /* Absolute path, redo everything without
 537                                  * the leading slash */
 538                                 next = name = link_name + 1;
 539                                 root_inum = 1;
 540                                 continue;
 541                         }
 542                         /* Relative to cur dir */
 543                         sprintf(buf, "%s/%s",
 544                                         link_name, next == NULL ? "" : next);
 545                         memcpy(symlinkpath, buf, sizeof(buf));
 546                         next = name = symlinkpath;
 547                         continue;
 548                 }
 549
 550                 /*
 551                  * Check if directory with this name exists
 552                  */
 553
 554                 /* Found the node!  */
 555                 if (!next || *next == '\0')
 556                         return inum;
 557
 558                 root_inum = inum;
 559                 name = next;
 560         }
 561
 562         return 0;
 563 }
 564
 565 int ubifs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
 566 {
 567         if (rbdd) {
 568                 debug("UBIFS cannot be used with normal block devices\n");
 569                 return -1;
 570         }
 571
 572         /*
 573          * Should never happen since blk_get_device_part_str() already checks
 574          * this, but better safe then sorry.
 575          */
 576         if (!ubifs_is_mounted()) {
 577                 debug("UBIFS not mounted, use ubifsmount to mount volume first!\n");
 578                 return -1;
 579         }
 580
 581         return 0;
 582 }
 583
 584 int ubifs_ls(const char *filename)
 585 {
 586         struct ubifs_info *c = ubifs_sb->s_fs_info;
 587         struct file *file;
 588         struct dentry *dentry;
 589         struct inode *dir;
 590         void *dirent = NULL;
 591         unsigned long inum;
 592         int ret = 0;
 593
 594         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
 595         inum = ubifs_findfile(ubifs_sb, (char *)filename);
 596         if (!inum) {
 597                 ret = -1;
 598                 goto out;
 599         }
 600
 601         file = kzalloc(sizeof(struct file), 0);
 602         dentry = kzalloc(sizeof(struct dentry), 0);
 603         dir = kzalloc(sizeof(struct inode), 0);
 604         if (!file || !dentry || !dir) {
 605                 printf("%s: Error, no memory for malloc!\n", __func__);
 606                 ret = -ENOMEM;
 607                 goto out_mem;
 608         }
 609
 610         dir->i_sb = ubifs_sb;
 611         file->f_path.dentry = dentry;
 612         file->f_path.dentry->d_parent = dentry;
 613         file->f_path.dentry->d_inode = dir;
 614         file->f_path.dentry->d_inode->i_ino = inum;
 615         file->f_pos = 1;
 616         file->private_data = NULL;
 617         ubifs_printdir(file, dirent);
 618
 619 out_mem:
 620         if (file)
 621                 free(file);
 622         if (dentry)
 623                 free(dentry);
 624         if (dir)
 625                 free(dir);
 626
 627 out:
 628         ubi_close_volume(c->ubi);
 629         return ret;
 630 }
 631
 632 int ubifs_exists(const char *filename)
 633 {
 634         struct ubifs_info *c = ubifs_sb->s_fs_info;
 635         unsigned long inum;
 636
 637         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
 638         inum = ubifs_findfile(ubifs_sb, (char *)filename);
 639         ubi_close_volume(c->ubi);
 640
 641         return inum != 0;
 642 }
 643
 644 int ubifs_size(const char *filename, loff_t *size)
 645 {
 646         struct ubifs_info *c = ubifs_sb->s_fs_info;
 647         unsigned long inum;
 648         struct inode *inode;
 649         int err = 0;
 650
 651         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
 652
 653         inum = ubifs_findfile(ubifs_sb, (char *)filename);
 654         if (!inum) {
 655                 err = -1;
 656                 goto out;
 657         }
 658
 659         inode = ubifs_iget(ubifs_sb, inum);
 660         if (IS_ERR(inode)) {
 661                 printf("%s: Error reading inode %ld!\n", __func__, inum);
 662                 err = PTR_ERR(inode);
 663                 goto out;
 664         }
 665
 666         *size = inode->i_size;
 667
 668         ubifs_iput(inode);
 669 out:
 670         ubi_close_volume(c->ubi);
 671         return err;
 672 }
 673
 674 /*
 675  * ubifsload...
 676  */
 677
 678 /* file.c */
 679
 680 static inline void *kmap(struct page *page)
 681 {
 682         return page->addr;
 683 }
 684
 685 static int read_block(struct inode *inode, void *addr, unsigned int block,
 686                       struct ubifs_data_node *dn)
 687 {
 688         struct ubifs_info *c = inode->i_sb->s_fs_info;
 689         int err, len, out_len;
 690         union ubifs_key key;
 691         unsigned int dlen;
 692
 693         data_key_init(c, &key, inode->i_ino, block);
 694         err = ubifs_tnc_lookup(c, &key, dn);
 695         if (err) {
 696                 if (err == -ENOENT)
 697                         /* Not found, so it must be a hole */
 698                         memset(addr, 0, UBIFS_BLOCK_SIZE);
 699                 return err;
 700         }
 701
 702         ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
 703
 704         len = le32_to_cpu(dn->size);
 705         if (len <= 0 || len > UBIFS_BLOCK_SIZE)
 706                 goto dump;
 707
 708         dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
 709         out_len = UBIFS_BLOCK_SIZE;
 710         err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len,
 711                                le16_to_cpu(dn->compr_type));
 712         if (err || len != out_len)
 713                 goto dump;
 714
 715         /*
 716          * Data length can be less than a full block, even for blocks that are
 717          * not the last in the file (e.g., as a result of making a hole and
 718          * appending data). Ensure that the remainder is zeroed out.
 719          */
 720         if (len < UBIFS_BLOCK_SIZE)
 721                 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
 722
 723         return 0;
 724
 725 dump:
 726         ubifs_err(c, "bad data node (block %u, inode %lu)",
 727                   block, inode->i_ino);
 728         ubifs_dump_node(c, dn);
 729         return -EINVAL;
 730 }
 731
 732 static int do_readpage(struct ubifs_info *c, struct inode *inode,
 733                        struct page *page, int last_block_size)
 734 {
 735         void *addr;
 736         int err = 0, i;
 737         unsigned int block, beyond;
 738         struct ubifs_data_node *dn;
 739         loff_t i_size = inode->i_size;
 740
 741         dbg_gen("ino %lu, pg %lu, i_size %lld",
 742                 inode->i_ino, page->index, i_size);
 743
 744         addr = kmap(page);
 745
 746         block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
 747         beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
 748         if (block >= beyond) {
 749                 /* Reading beyond inode */
 750                 memset(addr, 0, PAGE_CACHE_SIZE);
 751                 goto out;
 752         }
 753
 754         dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
 755         if (!dn)
 756                 return -ENOMEM;
 757
 758         i = 0;
 759         while (1) {
 760                 int ret;
 761
 762                 if (block >= beyond) {
 763                         /* Reading beyond inode */
 764                         err = -ENOENT;
 765                         memset(addr, 0, UBIFS_BLOCK_SIZE);
 766                 } else {
 767                         /*
 768                          * Reading last block? Make sure to not write beyond
 769                          * the requested size in the destination buffer.
 770                          */
 771                         if (((block + 1) == beyond) || last_block_size) {
 772                                 void *buff;
 773                                 int dlen;
 774
 775                                 /*
 776                                  * We need to buffer the data locally for the
 777                                  * last block. This is to not pad the
 778                                  * destination area to a multiple of
 779                                  * UBIFS_BLOCK_SIZE.
 780                                  */
 781                                 buff = malloc_cache_aligned(UBIFS_BLOCK_SIZE);
 782                                 if (!buff) {
 783                                         printf("%s: Error, malloc fails!\n",
 784                                                __func__);
 785                                         err = -ENOMEM;
 786                                         break;
 787                                 }
 788
 789                                 /* Read block-size into temp buffer */
 790                                 ret = read_block(inode, buff, block, dn);
 791                                 if (ret) {
 792                                         err = ret;
 793                                         if (err != -ENOENT) {
 794                                                 free(buff);
 795                                                 break;
 796                                         }
 797                                 }
 798
 799                                 if (last_block_size)
 800                                         dlen = last_block_size;
 801                                 else
 802                                         dlen = le32_to_cpu(dn->size);
 803
 804                                 /* Now copy required size back to dest */
 805                                 memcpy(addr, buff, dlen);
 806
 807                                 free(buff);
 808                         } else {
 809                                 ret = read_block(inode, addr, block, dn);
 810                                 if (ret) {
 811                                         err = ret;
 812                                         if (err != -ENOENT)
 813                                                 break;
 814                                 }
 815                         }
 816                 }
 817                 if (++i >= UBIFS_BLOCKS_PER_PAGE)
 818                         break;
 819                 block += 1;
 820                 addr += UBIFS_BLOCK_SIZE;
 821         }
 822         if (err) {
 823                 if (err == -ENOENT) {
 824                         /* Not found, so it must be a hole */
 825                         dbg_gen("hole");
 826                         goto out_free;
 827                 }
 828                 ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
 829                           page->index, inode->i_ino, err);
 830                 goto error;
 831         }
 832
 833 out_free:
 834         kfree(dn);
 835 out:
 836         return 0;
 837
 838 error:
 839         kfree(dn);
 840         return err;
 841 }
 842
 843 int ubifs_read(const char *filename, void *buf, loff_t offset,
 844                loff_t size, loff_t *actread)
 845 {
 846         struct ubifs_info *c = ubifs_sb->s_fs_info;
 847         unsigned long inum;
 848         struct inode *inode;
 849         struct page page;
 850         int err = 0;
 851         int i;
 852         int count;
 853         int last_block_size = 0;
 854
 855         *actread = 0;
 856
 857         if (offset & (PAGE_SIZE - 1)) {
 858                 printf("ubifs: Error offset must be a multiple of %d\n",
 859                        PAGE_SIZE);
 860                 return -1;
 861         }
 862
 863         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
 864         /* ubifs_findfile will resolve symlinks, so we know that we get
 865          * the real file here */
 866         inum = ubifs_findfile(ubifs_sb, (char *)filename);
 867         if (!inum) {
 868                 err = -1;
 869                 goto out;
 870         }
 871
 872         /*
 873          * Read file inode
 874          */
 875         inode = ubifs_iget(ubifs_sb, inum);
 876         if (IS_ERR(inode)) {
 877                 printf("%s: Error reading inode %ld!\n", __func__, inum);
 878                 err = PTR_ERR(inode);
 879                 goto out;
 880         }
 881
 882         if (offset > inode->i_size) {
 883                 printf("ubifs: Error offset (%lld) > file-size (%lld)\n",
 884                        offset, size);
 885                 err = -1;
 886                 goto put_inode;
 887         }
 888
 889         /*
 890          * If no size was specified or if size bigger than filesize
 891          * set size to filesize
 892          */
 893         if ((size == 0) || (size > (inode->i_size - offset)))
 894                 size = inode->i_size - offset;
 895
 896         count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
 897
 898         page.addr = buf;
 899         page.index = offset / PAGE_SIZE;
 900         page.inode = inode;
 901         for (i = 0; i < count; i++) {
 902                 /*
 903                  * Make sure to not read beyond the requested size
 904                  */
 905                 if (((i + 1) == count) && (size < inode->i_size))
 906                         last_block_size = size - (i * PAGE_SIZE);
 907
 908                 err = do_readpage(c, inode, &page, last_block_size);
 909                 if (err)
 910                         break;
 911
 912                 page.addr += PAGE_SIZE;
 913                 page.index++;
 914         }
 915
 916         if (err) {
 917                 printf("Error reading file '%s'\n", filename);
 918                 *actread = i * PAGE_SIZE;
 919         } else {
 920                 *actread = size;
 921         }
 922
 923 put_inode:
 924         ubifs_iput(inode);
 925
 926 out:
 927         ubi_close_volume(c->ubi);
 928         return err;
 929 }
 930
 931 void ubifs_close(void)
 932 {
 933 }
 934
 935 /* Compat wrappers for common/cmd_ubifs.c */
 936 int ubifs_load(char *filename, u32 addr, u32 size)
 937 {
 938         loff_t actread;
 939         int err;
 940
 941         printf("Loading file '%s' to addr 0x%08x...\n", filename, addr);
 942
 943         err = ubifs_read(filename, (void *)(uintptr_t)addr, 0, size, &actread);
 944         if (err == 0) {
 945                 env_set_hex("filesize", actread);
 946                 printf("Done\n");
 947         }
 948
 949         return err;
 950 }
 951
 952 void uboot_ubifs_umount(void)
 953 {
 954         if (ubifs_sb) {
 955                 printf("Unmounting UBIFS volume %s!\n",
 956                        ((struct ubifs_info *)(ubifs_sb->s_fs_info))->vi.name);
 957                 ubifs_umount(ubifs_sb->s_fs_info);
 958                 ubifs_sb = NULL;
 959         }
 960 }