xref: /openbmc/u-boot/fs/ubifs/ubifs.c (revision dd4671cb)
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 	kfree(file->private_data);
466 	free(file);
467 	free(dentry);
468 	free(dir);
469 
470 	return ret;
471 }
472 
473 static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
474 {
475 	int ret;
476 	char *next;
477 	char fpath[128];
478 	char symlinkpath[128];
479 	char *name = fpath;
480 	unsigned long root_inum = 1;
481 	unsigned long inum;
482 	int symlink_count = 0; /* Don't allow symlink recursion */
483 	char link_name[64];
484 
485 	strcpy(fpath, filename);
486 
487 	/* Remove all leading slashes */
488 	while (*name == '/')
489 		name++;
490 
491 	/*
492 	 * Handle root-direcoty ('/')
493 	 */
494 	inum = root_inum;
495 	if (!name || *name == '\0')
496 		return inum;
497 
498 	for (;;) {
499 		struct inode *inode;
500 		struct ubifs_inode *ui;
501 
502 		/* Extract the actual part from the pathname.  */
503 		next = strchr(name, '/');
504 		if (next) {
505 			/* Remove all leading slashes.  */
506 			while (*next == '/')
507 				*(next++) = '\0';
508 		}
509 
510 		ret = ubifs_finddir(sb, name, root_inum, &inum);
511 		if (!ret)
512 			return 0;
513 		inode = ubifs_iget(sb, inum);
514 
515 		if (!inode)
516 			return 0;
517 		ui = ubifs_inode(inode);
518 
519 		if ((inode->i_mode & S_IFMT) == S_IFLNK) {
520 			char buf[128];
521 
522 			/* We have some sort of symlink recursion, bail out */
523 			if (symlink_count++ > 8) {
524 				printf("Symlink recursion, aborting\n");
525 				return 0;
526 			}
527 			memcpy(link_name, ui->data, ui->data_len);
528 			link_name[ui->data_len] = '\0';
529 
530 			if (link_name[0] == '/') {
531 				/* Absolute path, redo everything without
532 				 * the leading slash */
533 				next = name = link_name + 1;
534 				root_inum = 1;
535 				continue;
536 			}
537 			/* Relative to cur dir */
538 			sprintf(buf, "%s/%s",
539 					link_name, next == NULL ? "" : next);
540 			memcpy(symlinkpath, buf, sizeof(buf));
541 			next = name = symlinkpath;
542 			continue;
543 		}
544 
545 		/*
546 		 * Check if directory with this name exists
547 		 */
548 
549 		/* Found the node!  */
550 		if (!next || *next == '\0')
551 			return inum;
552 
553 		root_inum = inum;
554 		name = next;
555 	}
556 
557 	return 0;
558 }
559 
560 int ubifs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
561 {
562 	if (rbdd) {
563 		debug("UBIFS cannot be used with normal block devices\n");
564 		return -1;
565 	}
566 
567 	/*
568 	 * Should never happen since blk_get_device_part_str() already checks
569 	 * this, but better safe then sorry.
570 	 */
571 	if (!ubifs_is_mounted()) {
572 		debug("UBIFS not mounted, use ubifsmount to mount volume first!\n");
573 		return -1;
574 	}
575 
576 	return 0;
577 }
578 
579 int ubifs_ls(const char *filename)
580 {
581 	struct ubifs_info *c = ubifs_sb->s_fs_info;
582 	struct file *file;
583 	struct dentry *dentry;
584 	struct inode *dir;
585 	void *dirent = NULL;
586 	unsigned long inum;
587 	int ret = 0;
588 
589 	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
590 	inum = ubifs_findfile(ubifs_sb, (char *)filename);
591 	if (!inum) {
592 		ret = -1;
593 		goto out;
594 	}
595 
596 	file = kzalloc(sizeof(struct file), 0);
597 	dentry = kzalloc(sizeof(struct dentry), 0);
598 	dir = kzalloc(sizeof(struct inode), 0);
599 	if (!file || !dentry || !dir) {
600 		printf("%s: Error, no memory for malloc!\n", __func__);
601 		ret = -ENOMEM;
602 		goto out_mem;
603 	}
604 
605 	dir->i_sb = ubifs_sb;
606 	file->f_path.dentry = dentry;
607 	file->f_path.dentry->d_parent = dentry;
608 	file->f_path.dentry->d_inode = dir;
609 	file->f_path.dentry->d_inode->i_ino = inum;
610 	file->f_pos = 1;
611 	file->private_data = NULL;
612 	ubifs_printdir(file, dirent);
613 
614 out_mem:
615 	if (file)
616 		free(file);
617 	if (dentry)
618 		free(dentry);
619 	if (dir)
620 		free(dir);
621 
622 out:
623 	ubi_close_volume(c->ubi);
624 	return ret;
625 }
626 
627 int ubifs_exists(const char *filename)
628 {
629 	struct ubifs_info *c = ubifs_sb->s_fs_info;
630 	unsigned long inum;
631 
632 	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
633 	inum = ubifs_findfile(ubifs_sb, (char *)filename);
634 	ubi_close_volume(c->ubi);
635 
636 	return inum != 0;
637 }
638 
639 int ubifs_size(const char *filename, loff_t *size)
640 {
641 	struct ubifs_info *c = ubifs_sb->s_fs_info;
642 	unsigned long inum;
643 	struct inode *inode;
644 	int err = 0;
645 
646 	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
647 
648 	inum = ubifs_findfile(ubifs_sb, (char *)filename);
649 	if (!inum) {
650 		err = -1;
651 		goto out;
652 	}
653 
654 	inode = ubifs_iget(ubifs_sb, inum);
655 	if (IS_ERR(inode)) {
656 		printf("%s: Error reading inode %ld!\n", __func__, inum);
657 		err = PTR_ERR(inode);
658 		goto out;
659 	}
660 
661 	*size = inode->i_size;
662 
663 	ubifs_iput(inode);
664 out:
665 	ubi_close_volume(c->ubi);
666 	return err;
667 }
668 
669 /*
670  * ubifsload...
671  */
672 
673 /* file.c */
674 
675 static inline void *kmap(struct page *page)
676 {
677 	return page->addr;
678 }
679 
680 static int read_block(struct inode *inode, void *addr, unsigned int block,
681 		      struct ubifs_data_node *dn)
682 {
683 	struct ubifs_info *c = inode->i_sb->s_fs_info;
684 	int err, len, out_len;
685 	union ubifs_key key;
686 	unsigned int dlen;
687 
688 	data_key_init(c, &key, inode->i_ino, block);
689 	err = ubifs_tnc_lookup(c, &key, dn);
690 	if (err) {
691 		if (err == -ENOENT)
692 			/* Not found, so it must be a hole */
693 			memset(addr, 0, UBIFS_BLOCK_SIZE);
694 		return err;
695 	}
696 
697 	ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
698 
699 	len = le32_to_cpu(dn->size);
700 	if (len <= 0 || len > UBIFS_BLOCK_SIZE)
701 		goto dump;
702 
703 	dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
704 	out_len = UBIFS_BLOCK_SIZE;
705 	err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len,
706 			       le16_to_cpu(dn->compr_type));
707 	if (err || len != out_len)
708 		goto dump;
709 
710 	/*
711 	 * Data length can be less than a full block, even for blocks that are
712 	 * not the last in the file (e.g., as a result of making a hole and
713 	 * appending data). Ensure that the remainder is zeroed out.
714 	 */
715 	if (len < UBIFS_BLOCK_SIZE)
716 		memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
717 
718 	return 0;
719 
720 dump:
721 	ubifs_err(c, "bad data node (block %u, inode %lu)",
722 		  block, inode->i_ino);
723 	ubifs_dump_node(c, dn);
724 	return -EINVAL;
725 }
726 
727 static int do_readpage(struct ubifs_info *c, struct inode *inode,
728 		       struct page *page, int last_block_size)
729 {
730 	void *addr;
731 	int err = 0, i;
732 	unsigned int block, beyond;
733 	struct ubifs_data_node *dn;
734 	loff_t i_size = inode->i_size;
735 
736 	dbg_gen("ino %lu, pg %lu, i_size %lld",
737 		inode->i_ino, page->index, i_size);
738 
739 	addr = kmap(page);
740 
741 	block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
742 	beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
743 	if (block >= beyond) {
744 		/* Reading beyond inode */
745 		memset(addr, 0, PAGE_CACHE_SIZE);
746 		goto out;
747 	}
748 
749 	dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
750 	if (!dn)
751 		return -ENOMEM;
752 
753 	i = 0;
754 	while (1) {
755 		int ret;
756 
757 		if (block >= beyond) {
758 			/* Reading beyond inode */
759 			err = -ENOENT;
760 			memset(addr, 0, UBIFS_BLOCK_SIZE);
761 		} else {
762 			/*
763 			 * Reading last block? Make sure to not write beyond
764 			 * the requested size in the destination buffer.
765 			 */
766 			if (((block + 1) == beyond) || last_block_size) {
767 				void *buff;
768 				int dlen;
769 
770 				/*
771 				 * We need to buffer the data locally for the
772 				 * last block. This is to not pad the
773 				 * destination area to a multiple of
774 				 * UBIFS_BLOCK_SIZE.
775 				 */
776 				buff = malloc_cache_aligned(UBIFS_BLOCK_SIZE);
777 				if (!buff) {
778 					printf("%s: Error, malloc fails!\n",
779 					       __func__);
780 					err = -ENOMEM;
781 					break;
782 				}
783 
784 				/* Read block-size into temp buffer */
785 				ret = read_block(inode, buff, block, dn);
786 				if (ret) {
787 					err = ret;
788 					if (err != -ENOENT) {
789 						free(buff);
790 						break;
791 					}
792 				}
793 
794 				if (last_block_size)
795 					dlen = last_block_size;
796 				else
797 					dlen = le32_to_cpu(dn->size);
798 
799 				/* Now copy required size back to dest */
800 				memcpy(addr, buff, dlen);
801 
802 				free(buff);
803 			} else {
804 				ret = read_block(inode, addr, block, dn);
805 				if (ret) {
806 					err = ret;
807 					if (err != -ENOENT)
808 						break;
809 				}
810 			}
811 		}
812 		if (++i >= UBIFS_BLOCKS_PER_PAGE)
813 			break;
814 		block += 1;
815 		addr += UBIFS_BLOCK_SIZE;
816 	}
817 	if (err) {
818 		if (err == -ENOENT) {
819 			/* Not found, so it must be a hole */
820 			dbg_gen("hole");
821 			goto out_free;
822 		}
823 		ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
824 			  page->index, inode->i_ino, err);
825 		goto error;
826 	}
827 
828 out_free:
829 	kfree(dn);
830 out:
831 	return 0;
832 
833 error:
834 	kfree(dn);
835 	return err;
836 }
837 
838 int ubifs_read(const char *filename, void *buf, loff_t offset,
839 	       loff_t size, loff_t *actread)
840 {
841 	struct ubifs_info *c = ubifs_sb->s_fs_info;
842 	unsigned long inum;
843 	struct inode *inode;
844 	struct page page;
845 	int err = 0;
846 	int i;
847 	int count;
848 	int last_block_size = 0;
849 
850 	*actread = 0;
851 
852 	if (offset & (PAGE_SIZE - 1)) {
853 		printf("ubifs: Error offset must be a multiple of %d\n",
854 		       PAGE_SIZE);
855 		return -1;
856 	}
857 
858 	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
859 	/* ubifs_findfile will resolve symlinks, so we know that we get
860 	 * the real file here */
861 	inum = ubifs_findfile(ubifs_sb, (char *)filename);
862 	if (!inum) {
863 		err = -1;
864 		goto out;
865 	}
866 
867 	/*
868 	 * Read file inode
869 	 */
870 	inode = ubifs_iget(ubifs_sb, inum);
871 	if (IS_ERR(inode)) {
872 		printf("%s: Error reading inode %ld!\n", __func__, inum);
873 		err = PTR_ERR(inode);
874 		goto out;
875 	}
876 
877 	if (offset > inode->i_size) {
878 		printf("ubifs: Error offset (%lld) > file-size (%lld)\n",
879 		       offset, size);
880 		err = -1;
881 		goto put_inode;
882 	}
883 
884 	/*
885 	 * If no size was specified or if size bigger than filesize
886 	 * set size to filesize
887 	 */
888 	if ((size == 0) || (size > (inode->i_size - offset)))
889 		size = inode->i_size - offset;
890 
891 	count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
892 
893 	page.addr = buf;
894 	page.index = offset / PAGE_SIZE;
895 	page.inode = inode;
896 	for (i = 0; i < count; i++) {
897 		/*
898 		 * Make sure to not read beyond the requested size
899 		 */
900 		if (((i + 1) == count) && (size < inode->i_size))
901 			last_block_size = size - (i * PAGE_SIZE);
902 
903 		err = do_readpage(c, inode, &page, last_block_size);
904 		if (err)
905 			break;
906 
907 		page.addr += PAGE_SIZE;
908 		page.index++;
909 	}
910 
911 	if (err) {
912 		printf("Error reading file '%s'\n", filename);
913 		*actread = i * PAGE_SIZE;
914 	} else {
915 		*actread = size;
916 	}
917 
918 put_inode:
919 	ubifs_iput(inode);
920 
921 out:
922 	ubi_close_volume(c->ubi);
923 	return err;
924 }
925 
926 void ubifs_close(void)
927 {
928 }
929 
930 /* Compat wrappers for common/cmd_ubifs.c */
931 int ubifs_load(char *filename, u32 addr, u32 size)
932 {
933 	loff_t actread;
934 	int err;
935 
936 	printf("Loading file '%s' to addr 0x%08x...\n", filename, addr);
937 
938 	err = ubifs_read(filename, (void *)(uintptr_t)addr, 0, size, &actread);
939 	if (err == 0) {
940 		env_set_hex("filesize", actread);
941 		printf("Done\n");
942 	}
943 
944 	return err;
945 }
946 
947 void uboot_ubifs_umount(void)
948 {
949 	if (ubifs_sb) {
950 		printf("Unmounting UBIFS volume %s!\n",
951 		       ((struct ubifs_info *)(ubifs_sb->s_fs_info))->vi.name);
952 		ubifs_umount(ubifs_sb->s_fs_info);
953 		ubifs_sb = NULL;
954 	}
955 }
956