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