configs: EB+MCF-EV123.h: Fix typo on CONFIG_SYS_HUSH_PARSER
[platform/kernel/u-boot.git] / 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         unsigned long len = in_len;
41         return zunzip(out, *out_len, (unsigned char *)in, &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
299         file = kzalloc(sizeof(struct file), 0);
300         dentry = kzalloc(sizeof(struct dentry), 0);
301         dir = kzalloc(sizeof(struct inode), 0);
302         if (!file || !dentry || !dir) {
303                 printf("%s: Error, no memory for malloc!\n", __func__);
304                 err = -ENOMEM;
305                 goto out;
306         }
307
308         dir->i_sb = sb;
309         file->f_path.dentry = dentry;
310         file->f_path.dentry->d_parent = dentry;
311         file->f_path.dentry->d_inode = dir;
312         file->f_path.dentry->d_inode->i_ino = root_inum;
313         c = sb->s_fs_info;
314
315         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
316
317         /* Find the first entry in TNC and save it */
318         lowest_dent_key(c, &key, dir->i_ino);
319         nm.name = NULL;
320         dent = ubifs_tnc_next_ent(c, &key, &nm);
321         if (IS_ERR(dent)) {
322                 err = PTR_ERR(dent);
323                 goto out;
324         }
325
326         file->f_pos = key_hash_flash(c, &dent->key);
327         file->private_data = dent;
328
329         while (1) {
330                 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
331                         dent->name, (unsigned long long)le64_to_cpu(dent->inum),
332                         key_hash_flash(c, &dent->key));
333                 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
334
335                 nm.len = le16_to_cpu(dent->nlen);
336                 if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
337                     (strlen(dirname) == nm.len)) {
338                         *inum = le64_to_cpu(dent->inum);
339                         return 1;
340                 }
341
342                 /* Switch to the next entry */
343                 key_read(c, &dent->key, &key);
344                 nm.name = (char *)dent->name;
345                 dent = ubifs_tnc_next_ent(c, &key, &nm);
346                 if (IS_ERR(dent)) {
347                         err = PTR_ERR(dent);
348                         goto out;
349                 }
350
351                 kfree(file->private_data);
352                 file->f_pos = key_hash_flash(c, &dent->key);
353                 file->private_data = dent;
354                 cond_resched();
355         }
356
357 out:
358         if (err != -ENOENT) {
359                 ubifs_err("cannot find next direntry, error %d", err);
360                 return err;
361         }
362
363         if (file->private_data)
364                 kfree(file->private_data);
365         if (file)
366                 free(file);
367         if (dentry)
368                 free(dentry);
369         if (dir)
370                 free(dir);
371
372         return 0;
373 }
374
375 static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
376 {
377         int ret;
378         char *next;
379         char fpath[128];
380         char symlinkpath[128];
381         char *name = fpath;
382         unsigned long root_inum = 1;
383         unsigned long inum;
384         int symlink_count = 0; /* Don't allow symlink recursion */
385         char link_name[64];
386
387         strcpy(fpath, filename);
388
389         /* Remove all leading slashes */
390         while (*name == '/')
391                 name++;
392
393         /*
394          * Handle root-direcoty ('/')
395          */
396         inum = root_inum;
397         if (!name || *name == '\0')
398                 return inum;
399
400         for (;;) {
401                 struct inode *inode;
402                 struct ubifs_inode *ui;
403
404                 /* Extract the actual part from the pathname.  */
405                 next = strchr(name, '/');
406                 if (next) {
407                         /* Remove all leading slashes.  */
408                         while (*next == '/')
409                                 *(next++) = '\0';
410                 }
411
412                 ret = ubifs_finddir(sb, name, root_inum, &inum);
413                 if (!ret)
414                         return 0;
415                 inode = ubifs_iget(sb, inum);
416
417                 if (!inode)
418                         return 0;
419                 ui = ubifs_inode(inode);
420
421                 if ((inode->i_mode & S_IFMT) == S_IFLNK) {
422                         char buf[128];
423
424                         /* We have some sort of symlink recursion, bail out */
425                         if (symlink_count++ > 8) {
426                                 printf("Symlink recursion, aborting\n");
427                                 return 0;
428                         }
429                         memcpy(link_name, ui->data, ui->data_len);
430                         link_name[ui->data_len] = '\0';
431
432                         if (link_name[0] == '/') {
433                                 /* Absolute path, redo everything without
434                                  * the leading slash */
435                                 next = name = link_name + 1;
436                                 root_inum = 1;
437                                 continue;
438                         }
439                         /* Relative to cur dir */
440                         sprintf(buf, "%s/%s",
441                                         link_name, next == NULL ? "" : next);
442                         memcpy(symlinkpath, buf, sizeof(buf));
443                         next = name = symlinkpath;
444                         continue;
445                 }
446
447                 /*
448                  * Check if directory with this name exists
449                  */
450
451                 /* Found the node!  */
452                 if (!next || *next == '\0')
453                         return inum;
454
455                 root_inum = inum;
456                 name = next;
457         }
458
459         return 0;
460 }
461
462 int ubifs_ls(char *filename)
463 {
464         struct ubifs_info *c = ubifs_sb->s_fs_info;
465         struct file *file;
466         struct dentry *dentry;
467         struct inode *dir;
468         void *dirent = NULL;
469         unsigned long inum;
470         int ret = 0;
471
472         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
473         inum = ubifs_findfile(ubifs_sb, filename);
474         if (!inum) {
475                 ret = -1;
476                 goto out;
477         }
478
479         file = kzalloc(sizeof(struct file), 0);
480         dentry = kzalloc(sizeof(struct dentry), 0);
481         dir = kzalloc(sizeof(struct inode), 0);
482         if (!file || !dentry || !dir) {
483                 printf("%s: Error, no memory for malloc!\n", __func__);
484                 ret = -ENOMEM;
485                 goto out_mem;
486         }
487
488         dir->i_sb = ubifs_sb;
489         file->f_path.dentry = dentry;
490         file->f_path.dentry->d_parent = dentry;
491         file->f_path.dentry->d_inode = dir;
492         file->f_path.dentry->d_inode->i_ino = inum;
493         file->f_pos = 1;
494         file->private_data = NULL;
495         ubifs_printdir(file, dirent);
496
497 out_mem:
498         if (file)
499                 free(file);
500         if (dentry)
501                 free(dentry);
502         if (dir)
503                 free(dir);
504
505 out:
506         ubi_close_volume(c->ubi);
507         return ret;
508 }
509
510 /*
511  * ubifsload...
512  */
513
514 /* file.c */
515
516 static inline void *kmap(struct page *page)
517 {
518         return page->addr;
519 }
520
521 static int read_block(struct inode *inode, void *addr, unsigned int block,
522                       struct ubifs_data_node *dn)
523 {
524         struct ubifs_info *c = inode->i_sb->s_fs_info;
525         int err, len, out_len;
526         union ubifs_key key;
527         unsigned int dlen;
528
529         data_key_init(c, &key, inode->i_ino, block);
530         err = ubifs_tnc_lookup(c, &key, dn);
531         if (err) {
532                 if (err == -ENOENT)
533                         /* Not found, so it must be a hole */
534                         memset(addr, 0, UBIFS_BLOCK_SIZE);
535                 return err;
536         }
537
538         ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
539
540         len = le32_to_cpu(dn->size);
541         if (len <= 0 || len > UBIFS_BLOCK_SIZE)
542                 goto dump;
543
544         dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
545         out_len = UBIFS_BLOCK_SIZE;
546         err = ubifs_decompress(&dn->data, dlen, addr, &out_len,
547                                le16_to_cpu(dn->compr_type));
548         if (err || len != out_len)
549                 goto dump;
550
551         /*
552          * Data length can be less than a full block, even for blocks that are
553          * not the last in the file (e.g., as a result of making a hole and
554          * appending data). Ensure that the remainder is zeroed out.
555          */
556         if (len < UBIFS_BLOCK_SIZE)
557                 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
558
559         return 0;
560
561 dump:
562         ubifs_err("bad data node (block %u, inode %lu)",
563                   block, inode->i_ino);
564         dbg_dump_node(c, dn);
565         return -EINVAL;
566 }
567
568 static int do_readpage(struct ubifs_info *c, struct inode *inode,
569                        struct page *page, int last_block_size)
570 {
571         void *addr;
572         int err = 0, i;
573         unsigned int block, beyond;
574         struct ubifs_data_node *dn;
575         loff_t i_size = inode->i_size;
576
577         dbg_gen("ino %lu, pg %lu, i_size %lld",
578                 inode->i_ino, page->index, i_size);
579
580         addr = kmap(page);
581
582         block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
583         beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
584         if (block >= beyond) {
585                 /* Reading beyond inode */
586                 memset(addr, 0, PAGE_CACHE_SIZE);
587                 goto out;
588         }
589
590         dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
591         if (!dn)
592                 return -ENOMEM;
593
594         i = 0;
595         while (1) {
596                 int ret;
597
598                 if (block >= beyond) {
599                         /* Reading beyond inode */
600                         err = -ENOENT;
601                         memset(addr, 0, UBIFS_BLOCK_SIZE);
602                 } else {
603                         /*
604                          * Reading last block? Make sure to not write beyond
605                          * the requested size in the destination buffer.
606                          */
607                         if (((block + 1) == beyond) || last_block_size) {
608                                 void *buff;
609                                 int dlen;
610
611                                 /*
612                                  * We need to buffer the data locally for the
613                                  * last block. This is to not pad the
614                                  * destination area to a multiple of
615                                  * UBIFS_BLOCK_SIZE.
616                                  */
617                                 buff = malloc(UBIFS_BLOCK_SIZE);
618                                 if (!buff) {
619                                         printf("%s: Error, malloc fails!\n",
620                                                __func__);
621                                         err = -ENOMEM;
622                                         break;
623                                 }
624
625                                 /* Read block-size into temp buffer */
626                                 ret = read_block(inode, buff, block, dn);
627                                 if (ret) {
628                                         err = ret;
629                                         if (err != -ENOENT) {
630                                                 free(buff);
631                                                 break;
632                                         }
633                                 }
634
635                                 if (last_block_size)
636                                         dlen = last_block_size;
637                                 else
638                                         dlen = le32_to_cpu(dn->size);
639
640                                 /* Now copy required size back to dest */
641                                 memcpy(addr, buff, dlen);
642
643                                 free(buff);
644                         } else {
645                                 ret = read_block(inode, addr, block, dn);
646                                 if (ret) {
647                                         err = ret;
648                                         if (err != -ENOENT)
649                                                 break;
650                                 }
651                         }
652                 }
653                 if (++i >= UBIFS_BLOCKS_PER_PAGE)
654                         break;
655                 block += 1;
656                 addr += UBIFS_BLOCK_SIZE;
657         }
658         if (err) {
659                 if (err == -ENOENT) {
660                         /* Not found, so it must be a hole */
661                         dbg_gen("hole");
662                         goto out_free;
663                 }
664                 ubifs_err("cannot read page %lu of inode %lu, error %d",
665                           page->index, inode->i_ino, err);
666                 goto error;
667         }
668
669 out_free:
670         kfree(dn);
671 out:
672         return 0;
673
674 error:
675         kfree(dn);
676         return err;
677 }
678
679 int ubifs_load(char *filename, u32 addr, u32 size)
680 {
681         struct ubifs_info *c = ubifs_sb->s_fs_info;
682         unsigned long inum;
683         struct inode *inode;
684         struct page page;
685         int err = 0;
686         int i;
687         int count;
688         int last_block_size = 0;
689         char buf [10];
690
691         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
692         /* ubifs_findfile will resolve symlinks, so we know that we get
693          * the real file here */
694         inum = ubifs_findfile(ubifs_sb, filename);
695         if (!inum) {
696                 err = -1;
697                 goto out;
698         }
699
700         /*
701          * Read file inode
702          */
703         inode = ubifs_iget(ubifs_sb, inum);
704         if (IS_ERR(inode)) {
705                 printf("%s: Error reading inode %ld!\n", __func__, inum);
706                 err = PTR_ERR(inode);
707                 goto out;
708         }
709
710         /*
711          * If no size was specified or if size bigger than filesize
712          * set size to filesize
713          */
714         if ((size == 0) || (size > inode->i_size))
715                 size = inode->i_size;
716
717         count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
718         printf("Loading file '%s' to addr 0x%08x with size %d (0x%08x)...\n",
719                filename, addr, size, size);
720
721         page.addr = (void *)addr;
722         page.index = 0;
723         page.inode = inode;
724         for (i = 0; i < count; i++) {
725                 /*
726                  * Make sure to not read beyond the requested size
727                  */
728                 if (((i + 1) == count) && (size < inode->i_size))
729                         last_block_size = size - (i * PAGE_SIZE);
730
731                 err = do_readpage(c, inode, &page, last_block_size);
732                 if (err)
733                         break;
734
735                 page.addr += PAGE_SIZE;
736                 page.index++;
737         }
738
739         if (err)
740                 printf("Error reading file '%s'\n", filename);
741         else {
742                 sprintf(buf, "%X", size);
743                 setenv("filesize", buf);
744                 printf("Done\n");
745         }
746
747         ubifs_iput(inode);
748
749 out:
750         ubi_close_volume(c->ubi);
751         return err;
752 }