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