blob: 273c0a96383538ccb35421a2694d3f0e272612df [file] [log] [blame]
Stefan Roese9eefe2a2009-03-19 15:35:05 +01001/*
2 * This file is part of UBIFS.
3 *
4 * Copyright (C) 2006-2008 Nokia Corporation.
5 *
Stefan Roeseb1a14f82010-11-01 17:28:00 +01006 * (C) Copyright 2008-2010
Stefan Roese9eefe2a2009-03-19 15:35:05 +01007 * Stefan Roese, DENX Software Engineering, sr@denx.de.
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License version 2 as published by
11 * the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * more details.
17 *
18 * You should have received a copy of the GNU General Public License along with
19 * this program; if not, write to the Free Software Foundation, Inc., 51
20 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Authors: Artem Bityutskiy (Битюцкий Артём)
23 * Adrian Hunter
24 */
25
26#include "ubifs.h"
Ricardo Ribalda Delgadoc1a0fd52009-04-27 18:33:33 +020027#include <u-boot/zlib.h>
Stefan Roese9eefe2a2009-03-19 15:35:05 +010028
Stefan Roese9eefe2a2009-03-19 15:35:05 +010029DECLARE_GLOBAL_DATA_PTR;
30
31/* compress.c */
32
33/*
Ricardo Ribalda Delgadoc1a0fd52009-04-27 18:33:33 +020034 * We need a wrapper for zunzip() because the parameters are
Stefan Roese9eefe2a2009-03-19 15:35:05 +010035 * incompatible with the lzo decompressor.
36 */
37static int gzip_decompress(const unsigned char *in, size_t in_len,
38 unsigned char *out, size_t *out_len)
39{
Veli-Pekka Peltola8044c132012-09-05 18:05:14 +030040 return zunzip(out, *out_len, (unsigned char *)in,
41 (unsigned long *)out_len, 0, 0);
Stefan Roese9eefe2a2009-03-19 15:35:05 +010042}
43
44/* Fake description object for the "none" compressor */
45static struct ubifs_compressor none_compr = {
46 .compr_type = UBIFS_COMPR_NONE,
47 .name = "no compression",
48 .capi_name = "",
49 .decompress = NULL,
50};
51
52static struct ubifs_compressor lzo_compr = {
53 .compr_type = UBIFS_COMPR_LZO,
54 .name = "LZO",
55 .capi_name = "lzo",
56 .decompress = lzo1x_decompress_safe,
57};
58
59static struct ubifs_compressor zlib_compr = {
60 .compr_type = UBIFS_COMPR_ZLIB,
61 .name = "zlib",
62 .capi_name = "deflate",
63 .decompress = gzip_decompress,
64};
65
66/* All UBIFS compressors */
67struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
68
69/**
70 * ubifs_decompress - decompress data.
71 * @in_buf: data to decompress
72 * @in_len: length of the data to decompress
73 * @out_buf: output buffer where decompressed data should
74 * @out_len: output length is returned here
75 * @compr_type: type of compression
76 *
77 * This function decompresses data from buffer @in_buf into buffer @out_buf.
78 * The length of the uncompressed data is returned in @out_len. This functions
79 * returns %0 on success or a negative error code on failure.
80 */
81int ubifs_decompress(const void *in_buf, int in_len, void *out_buf,
82 int *out_len, int compr_type)
83{
84 int err;
85 struct ubifs_compressor *compr;
86
87 if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
88 ubifs_err("invalid compression type %d", compr_type);
89 return -EINVAL;
90 }
91
92 compr = ubifs_compressors[compr_type];
93
94 if (unlikely(!compr->capi_name)) {
95 ubifs_err("%s compression is not compiled in", compr->name);
96 return -EINVAL;
97 }
98
99 if (compr_type == UBIFS_COMPR_NONE) {
100 memcpy(out_buf, in_buf, in_len);
101 *out_len = in_len;
102 return 0;
103 }
104
105 err = compr->decompress(in_buf, in_len, out_buf, (size_t *)out_len);
106 if (err)
107 ubifs_err("cannot decompress %d bytes, compressor %s, "
108 "error %d", in_len, compr->name, err);
109
110 return err;
111}
112
113/**
114 * compr_init - initialize a compressor.
115 * @compr: compressor description object
116 *
117 * This function initializes the requested compressor and returns zero in case
118 * of success or a negative error code in case of failure.
119 */
120static int __init compr_init(struct ubifs_compressor *compr)
121{
122 ubifs_compressors[compr->compr_type] = compr;
Peter Tyser521af042009-09-21 11:20:36 -0500123
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200124#ifdef CONFIG_NEEDS_MANUAL_RELOC
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100125 ubifs_compressors[compr->compr_type]->name += gd->reloc_off;
126 ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off;
127 ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off;
Peter Tyser521af042009-09-21 11:20:36 -0500128#endif
129
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100130 return 0;
131}
132
133/**
134 * ubifs_compressors_init - initialize UBIFS compressors.
135 *
136 * This function initializes the compressor which were compiled in. Returns
137 * zero in case of success and a negative error code in case of failure.
138 */
139int __init ubifs_compressors_init(void)
140{
141 int err;
142
143 err = compr_init(&lzo_compr);
144 if (err)
145 return err;
146
147 err = compr_init(&zlib_compr);
148 if (err)
149 return err;
150
Michael Lawnickfaac4fd2009-03-19 10:06:41 +0100151 err = compr_init(&none_compr);
152 if (err)
153 return err;
154
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100155 return 0;
156}
157
158/*
159 * ubifsls...
160 */
161
162static int filldir(struct ubifs_info *c, const char *name, int namlen,
163 u64 ino, unsigned int d_type)
164{
165 struct inode *inode;
166 char filetime[32];
167
168 switch (d_type) {
169 case UBIFS_ITYPE_REG:
170 printf("\t");
171 break;
172 case UBIFS_ITYPE_DIR:
173 printf("<DIR>\t");
174 break;
175 case UBIFS_ITYPE_LNK:
176 printf("<LNK>\t");
177 break;
178 default:
179 printf("other\t");
180 break;
181 }
182
183 inode = ubifs_iget(c->vfs_sb, ino);
184 if (IS_ERR(inode)) {
185 printf("%s: Error in ubifs_iget(), ino=%lld ret=%p!\n",
186 __func__, ino, inode);
187 return -1;
188 }
189 ctime_r((time_t *)&inode->i_mtime, filetime);
190 printf("%9lld %24.24s ", inode->i_size, filetime);
191 ubifs_iput(inode);
192
193 printf("%s\n", name);
194
195 return 0;
196}
197
198static int ubifs_printdir(struct file *file, void *dirent)
199{
200 int err, over = 0;
201 struct qstr nm;
202 union ubifs_key key;
203 struct ubifs_dent_node *dent;
204 struct inode *dir = file->f_path.dentry->d_inode;
205 struct ubifs_info *c = dir->i_sb->s_fs_info;
206
207 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
208
209 if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)
210 /*
211 * The directory was seek'ed to a senseless position or there
212 * are no more entries.
213 */
214 return 0;
215
216 if (file->f_pos == 1) {
217 /* Find the first entry in TNC and save it */
218 lowest_dent_key(c, &key, dir->i_ino);
219 nm.name = NULL;
220 dent = ubifs_tnc_next_ent(c, &key, &nm);
221 if (IS_ERR(dent)) {
222 err = PTR_ERR(dent);
223 goto out;
224 }
225
226 file->f_pos = key_hash_flash(c, &dent->key);
227 file->private_data = dent;
228 }
229
230 dent = file->private_data;
231 if (!dent) {
232 /*
233 * The directory was seek'ed to and is now readdir'ed.
234 * Find the entry corresponding to @file->f_pos or the
235 * closest one.
236 */
237 dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);
238 nm.name = NULL;
239 dent = ubifs_tnc_next_ent(c, &key, &nm);
240 if (IS_ERR(dent)) {
241 err = PTR_ERR(dent);
242 goto out;
243 }
244 file->f_pos = key_hash_flash(c, &dent->key);
245 file->private_data = dent;
246 }
247
248 while (1) {
249 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
250 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
251 key_hash_flash(c, &dent->key));
252 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
253
254 nm.len = le16_to_cpu(dent->nlen);
255 over = filldir(c, (char *)dent->name, nm.len,
256 le64_to_cpu(dent->inum), dent->type);
257 if (over)
258 return 0;
259
260 /* Switch to the next entry */
261 key_read(c, &dent->key, &key);
262 nm.name = (char *)dent->name;
263 dent = ubifs_tnc_next_ent(c, &key, &nm);
264 if (IS_ERR(dent)) {
265 err = PTR_ERR(dent);
266 goto out;
267 }
268
269 kfree(file->private_data);
270 file->f_pos = key_hash_flash(c, &dent->key);
271 file->private_data = dent;
272 cond_resched();
273 }
274
275out:
276 if (err != -ENOENT) {
277 ubifs_err("cannot find next direntry, error %d", err);
278 return err;
279 }
280
281 kfree(file->private_data);
282 file->private_data = NULL;
283 file->f_pos = 2;
284 return 0;
285}
286
287static int ubifs_finddir(struct super_block *sb, char *dirname,
288 unsigned long root_inum, unsigned long *inum)
289{
290 int err;
291 struct qstr nm;
292 union ubifs_key key;
293 struct ubifs_dent_node *dent;
294 struct ubifs_info *c;
295 struct file *file;
296 struct dentry *dentry;
297 struct inode *dir;
Stefan Roesebe739132012-08-28 14:00:24 +0200298 int ret = 0;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100299
300 file = kzalloc(sizeof(struct file), 0);
301 dentry = kzalloc(sizeof(struct dentry), 0);
302 dir = kzalloc(sizeof(struct inode), 0);
303 if (!file || !dentry || !dir) {
304 printf("%s: Error, no memory for malloc!\n", __func__);
305 err = -ENOMEM;
306 goto out;
307 }
308
309 dir->i_sb = sb;
310 file->f_path.dentry = dentry;
311 file->f_path.dentry->d_parent = dentry;
312 file->f_path.dentry->d_inode = dir;
313 file->f_path.dentry->d_inode->i_ino = root_inum;
314 c = sb->s_fs_info;
315
316 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
317
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 while (1) {
331 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
332 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
333 key_hash_flash(c, &dent->key));
334 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
335
336 nm.len = le16_to_cpu(dent->nlen);
337 if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
338 (strlen(dirname) == nm.len)) {
339 *inum = le64_to_cpu(dent->inum);
Stefan Roesebe739132012-08-28 14:00:24 +0200340 ret = 1;
341 goto out_free;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100342 }
343
344 /* Switch to the next entry */
345 key_read(c, &dent->key, &key);
346 nm.name = (char *)dent->name;
347 dent = ubifs_tnc_next_ent(c, &key, &nm);
348 if (IS_ERR(dent)) {
349 err = PTR_ERR(dent);
350 goto out;
351 }
352
353 kfree(file->private_data);
354 file->f_pos = key_hash_flash(c, &dent->key);
355 file->private_data = dent;
356 cond_resched();
357 }
358
359out:
Stefan Roesebe739132012-08-28 14:00:24 +0200360 if (err != -ENOENT)
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100361 ubifs_err("cannot find next direntry, error %d", err);
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100362
Stefan Roesebe739132012-08-28 14:00:24 +0200363out_free:
Wolfgang Denk3267bc12011-07-28 15:27:22 +0200364 if (file->private_data)
365 kfree(file->private_data);
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100366 if (file)
367 free(file);
368 if (dentry)
369 free(dentry);
370 if (dir)
371 free(dir);
372
Stefan Roesebe739132012-08-28 14:00:24 +0200373 return ret;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100374}
375
376static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
377{
378 int ret;
379 char *next;
380 char fpath[128];
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200381 char symlinkpath[128];
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100382 char *name = fpath;
383 unsigned long root_inum = 1;
384 unsigned long inum;
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200385 int symlink_count = 0; /* Don't allow symlink recursion */
Ricardo Ribalda Delgado64b68172010-12-02 15:02:35 +0100386 char link_name[64];
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100387
388 strcpy(fpath, filename);
389
390 /* Remove all leading slashes */
391 while (*name == '/')
392 name++;
393
394 /*
395 * Handle root-direcoty ('/')
396 */
397 inum = root_inum;
398 if (!name || *name == '\0')
399 return inum;
400
401 for (;;) {
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200402 struct inode *inode;
403 struct ubifs_inode *ui;
404
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100405 /* Extract the actual part from the pathname. */
406 next = strchr(name, '/');
407 if (next) {
408 /* Remove all leading slashes. */
409 while (*next == '/')
410 *(next++) = '\0';
411 }
412
413 ret = ubifs_finddir(sb, name, root_inum, &inum);
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200414 if (!ret)
415 return 0;
416 inode = ubifs_iget(sb, inum);
417
418 if (!inode)
419 return 0;
420 ui = ubifs_inode(inode);
421
422 if ((inode->i_mode & S_IFMT) == S_IFLNK) {
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200423 char buf[128];
424
425 /* We have some sort of symlink recursion, bail out */
426 if (symlink_count++ > 8) {
427 printf("Symlink recursion, aborting\n");
428 return 0;
429 }
430 memcpy(link_name, ui->data, ui->data_len);
431 link_name[ui->data_len] = '\0';
432
433 if (link_name[0] == '/') {
434 /* Absolute path, redo everything without
435 * the leading slash */
436 next = name = link_name + 1;
437 root_inum = 1;
438 continue;
439 }
440 /* Relative to cur dir */
Simon Kagstromef37c682009-09-25 14:05:57 +0200441 sprintf(buf, "%s/%s",
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200442 link_name, next == NULL ? "" : next);
443 memcpy(symlinkpath, buf, sizeof(buf));
444 next = name = symlinkpath;
445 continue;
446 }
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100447
448 /*
449 * Check if directory with this name exists
450 */
451
452 /* Found the node! */
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200453 if (!next || *next == '\0')
454 return inum;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100455
456 root_inum = inum;
457 name = next;
458 }
459
460 return 0;
461}
462
463int ubifs_ls(char *filename)
464{
465 struct ubifs_info *c = ubifs_sb->s_fs_info;
466 struct file *file;
467 struct dentry *dentry;
468 struct inode *dir;
469 void *dirent = NULL;
470 unsigned long inum;
471 int ret = 0;
472
473 c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
474 inum = ubifs_findfile(ubifs_sb, filename);
475 if (!inum) {
476 ret = -1;
477 goto out;
478 }
479
480 file = kzalloc(sizeof(struct file), 0);
481 dentry = kzalloc(sizeof(struct dentry), 0);
482 dir = kzalloc(sizeof(struct inode), 0);
483 if (!file || !dentry || !dir) {
484 printf("%s: Error, no memory for malloc!\n", __func__);
485 ret = -ENOMEM;
486 goto out_mem;
487 }
488
489 dir->i_sb = ubifs_sb;
490 file->f_path.dentry = dentry;
491 file->f_path.dentry->d_parent = dentry;
492 file->f_path.dentry->d_inode = dir;
493 file->f_path.dentry->d_inode->i_ino = inum;
494 file->f_pos = 1;
495 file->private_data = NULL;
496 ubifs_printdir(file, dirent);
497
498out_mem:
499 if (file)
500 free(file);
501 if (dentry)
502 free(dentry);
503 if (dir)
504 free(dir);
505
506out:
507 ubi_close_volume(c->ubi);
508 return ret;
509}
510
511/*
512 * ubifsload...
513 */
514
515/* file.c */
516
517static inline void *kmap(struct page *page)
518{
519 return page->addr;
520}
521
522static int read_block(struct inode *inode, void *addr, unsigned int block,
523 struct ubifs_data_node *dn)
524{
525 struct ubifs_info *c = inode->i_sb->s_fs_info;
526 int err, len, out_len;
527 union ubifs_key key;
528 unsigned int dlen;
529
530 data_key_init(c, &key, inode->i_ino, block);
531 err = ubifs_tnc_lookup(c, &key, dn);
532 if (err) {
533 if (err == -ENOENT)
534 /* Not found, so it must be a hole */
535 memset(addr, 0, UBIFS_BLOCK_SIZE);
536 return err;
537 }
538
539 ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
540
541 len = le32_to_cpu(dn->size);
542 if (len <= 0 || len > UBIFS_BLOCK_SIZE)
543 goto dump;
544
545 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
546 out_len = UBIFS_BLOCK_SIZE;
547 err = ubifs_decompress(&dn->data, dlen, addr, &out_len,
548 le16_to_cpu(dn->compr_type));
549 if (err || len != out_len)
550 goto dump;
551
552 /*
553 * Data length can be less than a full block, even for blocks that are
554 * not the last in the file (e.g., as a result of making a hole and
555 * appending data). Ensure that the remainder is zeroed out.
556 */
557 if (len < UBIFS_BLOCK_SIZE)
558 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
559
560 return 0;
561
562dump:
563 ubifs_err("bad data node (block %u, inode %lu)",
564 block, inode->i_ino);
565 dbg_dump_node(c, dn);
566 return -EINVAL;
567}
568
Stefan Roeseb1a14f82010-11-01 17:28:00 +0100569static int do_readpage(struct ubifs_info *c, struct inode *inode,
570 struct page *page, int last_block_size)
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100571{
572 void *addr;
573 int err = 0, i;
574 unsigned int block, beyond;
575 struct ubifs_data_node *dn;
576 loff_t i_size = inode->i_size;
577
578 dbg_gen("ino %lu, pg %lu, i_size %lld",
579 inode->i_ino, page->index, i_size);
580
581 addr = kmap(page);
582
583 block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
584 beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
585 if (block >= beyond) {
586 /* Reading beyond inode */
587 memset(addr, 0, PAGE_CACHE_SIZE);
588 goto out;
589 }
590
591 dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
Daniel Mack165f9852009-06-04 19:44:12 +0200592 if (!dn)
593 return -ENOMEM;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100594
595 i = 0;
596 while (1) {
597 int ret;
598
599 if (block >= beyond) {
600 /* Reading beyond inode */
601 err = -ENOENT;
602 memset(addr, 0, UBIFS_BLOCK_SIZE);
603 } else {
Stefan Roeseb1a14f82010-11-01 17:28:00 +0100604 /*
605 * Reading last block? Make sure to not write beyond
606 * the requested size in the destination buffer.
607 */
608 if (((block + 1) == beyond) || last_block_size) {
609 void *buff;
610 int dlen;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100611
Stefan Roeseb1a14f82010-11-01 17:28:00 +0100612 /*
613 * We need to buffer the data locally for the
614 * last block. This is to not pad the
615 * destination area to a multiple of
616 * UBIFS_BLOCK_SIZE.
617 */
618 buff = malloc(UBIFS_BLOCK_SIZE);
619 if (!buff) {
620 printf("%s: Error, malloc fails!\n",
621 __func__);
622 err = -ENOMEM;
623 break;
624 }
625
626 /* Read block-size into temp buffer */
627 ret = read_block(inode, buff, block, dn);
628 if (ret) {
629 err = ret;
630 if (err != -ENOENT) {
631 free(buff);
632 break;
633 }
634 }
635
636 if (last_block_size)
637 dlen = last_block_size;
638 else
639 dlen = le32_to_cpu(dn->size);
640
641 /* Now copy required size back to dest */
642 memcpy(addr, buff, dlen);
643
644 free(buff);
645 } else {
646 ret = read_block(inode, addr, block, dn);
647 if (ret) {
648 err = ret;
649 if (err != -ENOENT)
650 break;
651 }
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100652 }
653 }
654 if (++i >= UBIFS_BLOCKS_PER_PAGE)
655 break;
656 block += 1;
657 addr += UBIFS_BLOCK_SIZE;
658 }
659 if (err) {
660 if (err == -ENOENT) {
661 /* Not found, so it must be a hole */
662 dbg_gen("hole");
663 goto out_free;
664 }
665 ubifs_err("cannot read page %lu of inode %lu, error %d",
666 page->index, inode->i_ino, err);
667 goto error;
668 }
669
670out_free:
671 kfree(dn);
672out:
673 return 0;
674
675error:
676 kfree(dn);
677 return err;
678}
679
680int ubifs_load(char *filename, u32 addr, u32 size)
681{
682 struct ubifs_info *c = ubifs_sb->s_fs_info;
683 unsigned long inum;
684 struct inode *inode;
685 struct page page;
686 int err = 0;
687 int i;
688 int count;
Stefan Roeseb1a14f82010-11-01 17:28:00 +0100689 int last_block_size = 0;
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100690
691 c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
Simon Kagstrom9d7952e2009-09-15 09:53:29 +0200692 /* ubifs_findfile will resolve symlinks, so we know that we get
693 * the real file here */
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100694 inum = ubifs_findfile(ubifs_sb, filename);
695 if (!inum) {
696 err = -1;
697 goto out;
698 }
699
700 /*
701 * Read file inode
702 */
703 inode = ubifs_iget(ubifs_sb, inum);
704 if (IS_ERR(inode)) {
705 printf("%s: Error reading inode %ld!\n", __func__, inum);
706 err = PTR_ERR(inode);
707 goto out;
708 }
709
710 /*
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100711 * If no size was specified or if size bigger than filesize
712 * set size to filesize
713 */
714 if ((size == 0) || (size > inode->i_size))
715 size = inode->i_size;
716
717 count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
718 printf("Loading file '%s' to addr 0x%08x with size %d (0x%08x)...\n",
719 filename, addr, size, size);
720
721 page.addr = (void *)addr;
722 page.index = 0;
723 page.inode = inode;
724 for (i = 0; i < count; i++) {
Stefan Roeseb1a14f82010-11-01 17:28:00 +0100725 /*
726 * Make sure to not read beyond the requested size
727 */
728 if (((i + 1) == count) && (size < inode->i_size))
729 last_block_size = size - (i * PAGE_SIZE);
730
731 err = do_readpage(c, inode, &page, last_block_size);
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100732 if (err)
733 break;
734
735 page.addr += PAGE_SIZE;
736 page.index++;
737 }
738
739 if (err)
740 printf("Error reading file '%s'\n", filename);
Bastian Ruppert46d72742011-09-05 03:03:57 +0000741 else {
Simon Glass49c4f032013-02-24 17:33:23 +0000742 setenv_hex("filesize", size);
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100743 printf("Done\n");
Bastian Ruppert46d72742011-09-05 03:03:57 +0000744 }
Stefan Roese9eefe2a2009-03-19 15:35:05 +0100745
746 ubifs_iput(inode);
747
748out:
749 ubi_close_volume(c->ubi);
750 return err;
751}