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