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