2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation.
6 * (C) Copyright 2008-2009
7 * Stefan Roese, DENX Software Engineering, sr@denx.de.
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.
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
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
22 * Authors: Artem Bityutskiy (Битюцкий Артём)
27 #include <u-boot/zlib.h>
29 #if !defined(CONFIG_SYS_64BIT_VSPRINTF)
30 #warning Please define CONFIG_SYS_64BIT_VSPRINTF for correct output!
33 DECLARE_GLOBAL_DATA_PTR;
38 * We need a wrapper for zunzip() because the parameters are
39 * incompatible with the lzo decompressor.
41 static int gzip_decompress(const unsigned char *in, size_t in_len,
42 unsigned char *out, size_t *out_len)
44 unsigned long len = in_len;
45 return zunzip(out, *out_len, (unsigned char *)in, &len, 0, 0);
48 /* Fake description object for the "none" compressor */
49 static struct ubifs_compressor none_compr = {
50 .compr_type = UBIFS_COMPR_NONE,
51 .name = "no compression",
56 static struct ubifs_compressor lzo_compr = {
57 .compr_type = UBIFS_COMPR_LZO,
60 .decompress = lzo1x_decompress_safe,
63 static struct ubifs_compressor zlib_compr = {
64 .compr_type = UBIFS_COMPR_ZLIB,
66 .capi_name = "deflate",
67 .decompress = gzip_decompress,
70 /* All UBIFS compressors */
71 struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
74 * ubifs_decompress - decompress data.
75 * @in_buf: data to decompress
76 * @in_len: length of the data to decompress
77 * @out_buf: output buffer where decompressed data should
78 * @out_len: output length is returned here
79 * @compr_type: type of compression
81 * This function decompresses data from buffer @in_buf into buffer @out_buf.
82 * The length of the uncompressed data is returned in @out_len. This functions
83 * returns %0 on success or a negative error code on failure.
85 int ubifs_decompress(const void *in_buf, int in_len, void *out_buf,
86 int *out_len, int compr_type)
89 struct ubifs_compressor *compr;
91 if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) {
92 ubifs_err("invalid compression type %d", compr_type);
96 compr = ubifs_compressors[compr_type];
98 if (unlikely(!compr->capi_name)) {
99 ubifs_err("%s compression is not compiled in", compr->name);
103 if (compr_type == UBIFS_COMPR_NONE) {
104 memcpy(out_buf, in_buf, in_len);
109 err = compr->decompress(in_buf, in_len, out_buf, (size_t *)out_len);
111 ubifs_err("cannot decompress %d bytes, compressor %s, "
112 "error %d", in_len, compr->name, err);
118 * compr_init - initialize a compressor.
119 * @compr: compressor description object
121 * This function initializes the requested compressor and returns zero in case
122 * of success or a negative error code in case of failure.
124 static int __init compr_init(struct ubifs_compressor *compr)
126 ubifs_compressors[compr->compr_type] = compr;
127 ubifs_compressors[compr->compr_type]->name += gd->reloc_off;
128 ubifs_compressors[compr->compr_type]->capi_name += gd->reloc_off;
129 ubifs_compressors[compr->compr_type]->decompress += gd->reloc_off;
134 * ubifs_compressors_init - initialize UBIFS compressors.
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.
139 int __init ubifs_compressors_init(void)
143 err = compr_init(&lzo_compr);
147 err = compr_init(&zlib_compr);
151 err = compr_init(&none_compr);
162 static int filldir(struct ubifs_info *c, const char *name, int namlen,
163 u64 ino, unsigned int d_type)
169 case UBIFS_ITYPE_REG:
172 case UBIFS_ITYPE_DIR:
175 case UBIFS_ITYPE_LNK:
183 inode = ubifs_iget(c->vfs_sb, ino);
185 printf("%s: Error in ubifs_iget(), ino=%lld ret=%p!\n",
186 __func__, ino, inode);
189 ctime_r((time_t *)&inode->i_mtime, filetime);
190 printf("%9lld %24.24s ", inode->i_size, filetime);
193 printf("%s\n", name);
198 static int ubifs_printdir(struct file *file, void *dirent)
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;
207 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
209 if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)
211 * The directory was seek'ed to a senseless position or there
212 * are no more entries.
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);
220 dent = ubifs_tnc_next_ent(c, &key, &nm);
226 file->f_pos = key_hash_flash(c, &dent->key);
227 file->private_data = dent;
230 dent = file->private_data;
233 * The directory was seek'ed to and is now readdir'ed.
234 * Find the entry corresponding to @file->f_pos or the
237 dent_key_init_hash(c, &key, dir->i_ino, file->f_pos);
239 dent = ubifs_tnc_next_ent(c, &key, &nm);
244 file->f_pos = key_hash_flash(c, &dent->key);
245 file->private_data = dent;
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);
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);
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);
269 kfree(file->private_data);
270 file->f_pos = key_hash_flash(c, &dent->key);
271 file->private_data = dent;
276 if (err != -ENOENT) {
277 ubifs_err("cannot find next direntry, error %d", err);
281 kfree(file->private_data);
282 file->private_data = NULL;
287 static int ubifs_finddir(struct super_block *sb, char *dirname,
288 unsigned long root_inum, unsigned long *inum)
293 struct ubifs_dent_node *dent;
294 struct ubifs_info *c;
296 struct dentry *dentry;
299 file = kzalloc(sizeof(struct file), 0);
300 dentry = kzalloc(sizeof(struct dentry), 0);
301 dir = kzalloc(sizeof(struct inode), 0);
302 if (!file || !dentry || !dir) {
303 printf("%s: Error, no memory for malloc!\n", __func__);
309 file->f_path.dentry = dentry;
310 file->f_path.dentry->d_parent = dentry;
311 file->f_path.dentry->d_inode = dir;
312 file->f_path.dentry->d_inode->i_ino = root_inum;
315 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
317 /* Find the first entry in TNC and save it */
318 lowest_dent_key(c, &key, dir->i_ino);
320 dent = ubifs_tnc_next_ent(c, &key, &nm);
326 file->f_pos = key_hash_flash(c, &dent->key);
327 file->private_data = dent;
330 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
331 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
332 key_hash_flash(c, &dent->key));
333 ubifs_assert(le64_to_cpu(dent->ch.sqnum) > ubifs_inode(dir)->creat_sqnum);
335 nm.len = le16_to_cpu(dent->nlen);
336 if ((strncmp(dirname, (char *)dent->name, nm.len) == 0) &&
337 (strlen(dirname) == nm.len)) {
338 *inum = le64_to_cpu(dent->inum);
342 /* Switch to the next entry */
343 key_read(c, &dent->key, &key);
344 nm.name = (char *)dent->name;
345 dent = ubifs_tnc_next_ent(c, &key, &nm);
351 kfree(file->private_data);
352 file->f_pos = key_hash_flash(c, &dent->key);
353 file->private_data = dent;
358 if (err != -ENOENT) {
359 ubifs_err("cannot find next direntry, error %d", err);
370 if (file->private_data)
371 kfree(file->private_data);
372 file->private_data = NULL;
377 static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
382 char symlinkpath[128];
384 unsigned long root_inum = 1;
386 int symlink_count = 0; /* Don't allow symlink recursion */
388 strcpy(fpath, filename);
390 /* Remove all leading slashes */
395 * Handle root-direcoty ('/')
398 if (!name || *name == '\0')
403 struct ubifs_inode *ui;
405 /* Extract the actual part from the pathname. */
406 next = strchr(name, '/');
408 /* Remove all leading slashes. */
413 ret = ubifs_finddir(sb, name, root_inum, &inum);
416 inode = ubifs_iget(sb, inum);
420 ui = ubifs_inode(inode);
422 if ((inode->i_mode & S_IFMT) == S_IFLNK) {
426 /* We have some sort of symlink recursion, bail out */
427 if (symlink_count++ > 8) {
428 printf("Symlink recursion, aborting\n");
431 memcpy(link_name, ui->data, ui->data_len);
432 link_name[ui->data_len] = '\0';
434 if (link_name[0] == '/') {
435 /* Absolute path, redo everything without
436 * the leading slash */
437 next = name = link_name + 1;
441 /* Relative to cur dir */
442 sprintf(buf, "%s/%s",
443 link_name, next == NULL ? "" : next);
444 memcpy(symlinkpath, buf, sizeof(buf));
445 next = name = symlinkpath;
450 * Check if directory with this name exists
453 /* Found the node! */
454 if (!next || *next == '\0')
464 int ubifs_ls(char *filename)
466 struct ubifs_info *c = ubifs_sb->s_fs_info;
468 struct dentry *dentry;
474 c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
475 inum = ubifs_findfile(ubifs_sb, filename);
481 file = kzalloc(sizeof(struct file), 0);
482 dentry = kzalloc(sizeof(struct dentry), 0);
483 dir = kzalloc(sizeof(struct inode), 0);
484 if (!file || !dentry || !dir) {
485 printf("%s: Error, no memory for malloc!\n", __func__);
490 dir->i_sb = ubifs_sb;
491 file->f_path.dentry = dentry;
492 file->f_path.dentry->d_parent = dentry;
493 file->f_path.dentry->d_inode = dir;
494 file->f_path.dentry->d_inode->i_ino = inum;
496 file->private_data = NULL;
497 ubifs_printdir(file, dirent);
508 ubi_close_volume(c->ubi);
518 static inline void *kmap(struct page *page)
523 static int read_block(struct inode *inode, void *addr, unsigned int block,
524 struct ubifs_data_node *dn)
526 struct ubifs_info *c = inode->i_sb->s_fs_info;
527 int err, len, out_len;
531 data_key_init(c, &key, inode->i_ino, block);
532 err = ubifs_tnc_lookup(c, &key, dn);
535 /* Not found, so it must be a hole */
536 memset(addr, 0, UBIFS_BLOCK_SIZE);
540 ubifs_assert(le64_to_cpu(dn->ch.sqnum) > ubifs_inode(inode)->creat_sqnum);
542 len = le32_to_cpu(dn->size);
543 if (len <= 0 || len > UBIFS_BLOCK_SIZE)
546 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
547 out_len = UBIFS_BLOCK_SIZE;
548 err = ubifs_decompress(&dn->data, dlen, addr, &out_len,
549 le16_to_cpu(dn->compr_type));
550 if (err || len != out_len)
554 * Data length can be less than a full block, even for blocks that are
555 * not the last in the file (e.g., as a result of making a hole and
556 * appending data). Ensure that the remainder is zeroed out.
558 if (len < UBIFS_BLOCK_SIZE)
559 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
564 ubifs_err("bad data node (block %u, inode %lu)",
565 block, inode->i_ino);
566 dbg_dump_node(c, dn);
570 static int do_readpage(struct ubifs_info *c, struct inode *inode, struct page *page)
574 unsigned int block, beyond;
575 struct ubifs_data_node *dn;
576 loff_t i_size = inode->i_size;
578 dbg_gen("ino %lu, pg %lu, i_size %lld",
579 inode->i_ino, page->index, i_size);
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);
591 dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS);
599 if (block >= beyond) {
600 /* Reading beyond inode */
602 memset(addr, 0, UBIFS_BLOCK_SIZE);
604 ret = read_block(inode, addr, block, dn);
609 } else if (block + 1 == beyond) {
610 int dlen = le32_to_cpu(dn->size);
611 int ilen = i_size & (UBIFS_BLOCK_SIZE - 1);
613 if (ilen && ilen < dlen)
614 memset(addr + ilen, 0, dlen - ilen);
617 if (++i >= UBIFS_BLOCKS_PER_PAGE)
620 addr += UBIFS_BLOCK_SIZE;
623 if (err == -ENOENT) {
624 /* Not found, so it must be a hole */
628 ubifs_err("cannot read page %lu of inode %lu, error %d",
629 page->index, inode->i_ino, err);
643 int ubifs_load(char *filename, u32 addr, u32 size)
645 struct ubifs_info *c = ubifs_sb->s_fs_info;
653 c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
654 /* ubifs_findfile will resolve symlinks, so we know that we get
655 * the real file here */
656 inum = ubifs_findfile(ubifs_sb, filename);
665 inode = ubifs_iget(ubifs_sb, inum);
667 printf("%s: Error reading inode %ld!\n", __func__, inum);
668 err = PTR_ERR(inode);
673 * If no size was specified or if size bigger than filesize
674 * set size to filesize
676 if ((size == 0) || (size > inode->i_size))
677 size = inode->i_size;
679 count = (size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT;
680 printf("Loading file '%s' to addr 0x%08x with size %d (0x%08x)...\n",
681 filename, addr, size, size);
683 page.addr = (void *)addr;
686 for (i = 0; i < count; i++) {
687 err = do_readpage(c, inode, &page);
691 page.addr += PAGE_SIZE;
696 printf("Error reading file '%s'\n", filename);
703 ubi_close_volume(c->ubi);