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