xref: /openbmc/u-boot/fs/ubifs/ubifs.c (revision 3cbeb0f0)
1 /*
2  * This file is part of UBIFS.
3  *
4  * Copyright (C) 2006-2008 Nokia Corporation.
5  *
6  * (C) Copyright 2008-2010
7  * 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"
27 #include <u-boot/zlib.h>
28 
29 DECLARE_GLOBAL_DATA_PTR;
30 
31 /* compress.c */
32 
33 /*
34  * We need a wrapper for zunzip() because the parameters are
35  * incompatible with the lzo decompressor.
36  */
37 static int gzip_decompress(const unsigned char *in, size_t in_len,
38 			   unsigned char *out, size_t *out_len)
39 {
40 	return zunzip(out, *out_len, (unsigned char *)in,
41 		      (unsigned long *)out_len, 0, 0);
42 }
43 
44 /* Fake description object for the "none" compressor */
45 static struct ubifs_compressor none_compr = {
46 	.compr_type = UBIFS_COMPR_NONE,
47 	.name = "no compression",
48 	.capi_name = "",
49 	.decompress = NULL,
50 };
51 
52 static 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 
59 static 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 */
67 struct 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  */
81 int 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  */
120 static int __init compr_init(struct ubifs_compressor *compr)
121 {
122 	ubifs_compressors[compr->compr_type] = compr;
123 
124 #ifdef CONFIG_NEEDS_MANUAL_RELOC
125 	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;
128 #endif
129 
130 	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  */
139 int __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 
151 	err = compr_init(&none_compr);
152 	if (err)
153 		return err;
154 
155 	return 0;
156 }
157 
158 /*
159  * ubifsls...
160  */
161 
162 static 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 
198 static 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 
275 out:
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 
287 static 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;
298 	int ret = 0;
299 
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);
340 			ret = 1;
341 			goto out_free;
342 		}
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 
359 out:
360 	if (err != -ENOENT)
361 		ubifs_err("cannot find next direntry, error %d", err);
362 
363 out_free:
364 	if (file->private_data)
365 		kfree(file->private_data);
366 	if (file)
367 		free(file);
368 	if (dentry)
369 		free(dentry);
370 	if (dir)
371 		free(dir);
372 
373 	return ret;
374 }
375 
376 static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
377 {
378 	int ret;
379 	char *next;
380 	char fpath[128];
381 	char symlinkpath[128];
382 	char *name = fpath;
383 	unsigned long root_inum = 1;
384 	unsigned long inum;
385 	int symlink_count = 0; /* Don't allow symlink recursion */
386 	char link_name[64];
387 
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 (;;) {
402 		struct inode *inode;
403 		struct ubifs_inode *ui;
404 
405 		/* 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);
414 		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) {
423 			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 */
441 			sprintf(buf, "%s/%s",
442 					link_name, next == NULL ? "" : next);
443 			memcpy(symlinkpath, buf, sizeof(buf));
444 			next = name = symlinkpath;
445 			continue;
446 		}
447 
448 		/*
449 		 * Check if directory with this name exists
450 		 */
451 
452 		/* Found the node!  */
453 		if (!next || *next == '\0')
454 			return inum;
455 
456 		root_inum = inum;
457 		name = next;
458 	}
459 
460 	return 0;
461 }
462 
463 int 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 
498 out_mem:
499 	if (file)
500 		free(file);
501 	if (dentry)
502 		free(dentry);
503 	if (dir)
504 		free(dir);
505 
506 out:
507 	ubi_close_volume(c->ubi);
508 	return ret;
509 }
510 
511 /*
512  * ubifsload...
513  */
514 
515 /* file.c */
516 
517 static inline void *kmap(struct page *page)
518 {
519 	return page->addr;
520 }
521 
522 static 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 
562 dump:
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 
569 static int do_readpage(struct ubifs_info *c, struct inode *inode,
570 		       struct page *page, int last_block_size)
571 {
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);
592 	if (!dn)
593 		return -ENOMEM;
594 
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 {
604 			/*
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;
611 
612 				/*
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 				}
652 			}
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 
670 out_free:
671 	kfree(dn);
672 out:
673 	return 0;
674 
675 error:
676 	kfree(dn);
677 	return err;
678 }
679 
680 int 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;
689 	int last_block_size = 0;
690 
691 	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY);
692 	/* ubifs_findfile will resolve symlinks, so we know that we get
693 	 * the real file here */
694 	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 	/*
711 	 * 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++) {
725 		/*
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);
732 		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);
741 	else {
742 		setenv_hex("filesize", size);
743 		printf("Done\n");
744 	}
745 
746 	ubifs_iput(inode);
747 
748 out:
749 	ubi_close_volume(c->ubi);
750 	return err;
751 }
752