xref: /openbmc/linux/fs/f2fs/inline.c (revision 2d96b44f) 
1 /*
2  * fs/f2fs/inline.c
3  * Copyright (c) 2013, Intel Corporation
4  * Authors: Huajun Li <huajun.li@intel.com>
5  *          Haicheng Li <haicheng.li@intel.com>
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 
11 #include <linux/fs.h>
12 #include <linux/f2fs_fs.h>
13 
14 #include "f2fs.h"
15 #include "node.h"
16 
17 bool f2fs_may_inline_data(struct inode *inode)
18 {
19 	if (f2fs_is_atomic_file(inode))
20 		return false;
21 
22 	if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
23 		return false;
24 
25 	if (i_size_read(inode) > MAX_INLINE_DATA)
26 		return false;
27 
28 	if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
29 		return false;
30 
31 	return true;
32 }
33 
34 bool f2fs_may_inline_dentry(struct inode *inode)
35 {
36 	if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
37 		return false;
38 
39 	if (!S_ISDIR(inode->i_mode))
40 		return false;
41 
42 	return true;
43 }
44 
45 void read_inline_data(struct page *page, struct page *ipage)
46 {
47 	void *src_addr, *dst_addr;
48 
49 	if (PageUptodate(page))
50 		return;
51 
52 	f2fs_bug_on(F2FS_P_SB(page), page->index);
53 
54 	zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);
55 
56 	/* Copy the whole inline data block */
57 	src_addr = inline_data_addr(ipage);
58 	dst_addr = kmap_atomic(page);
59 	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
60 	flush_dcache_page(page);
61 	kunmap_atomic(dst_addr);
62 	if (!PageUptodate(page))
63 		SetPageUptodate(page);
64 }
65 
66 bool truncate_inline_inode(struct page *ipage, u64 from)
67 {
68 	void *addr;
69 
70 	if (from >= MAX_INLINE_DATA)
71 		return false;
72 
73 	addr = inline_data_addr(ipage);
74 
75 	f2fs_wait_on_page_writeback(ipage, NODE, true);
76 	memset(addr + from, 0, MAX_INLINE_DATA - from);
77 	set_page_dirty(ipage);
78 	return true;
79 }
80 
81 int f2fs_read_inline_data(struct inode *inode, struct page *page)
82 {
83 	struct page *ipage;
84 
85 	ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
86 	if (IS_ERR(ipage)) {
87 		unlock_page(page);
88 		return PTR_ERR(ipage);
89 	}
90 
91 	if (!f2fs_has_inline_data(inode)) {
92 		f2fs_put_page(ipage, 1);
93 		return -EAGAIN;
94 	}
95 
96 	if (page->index)
97 		zero_user_segment(page, 0, PAGE_SIZE);
98 	else
99 		read_inline_data(page, ipage);
100 
101 	if (!PageUptodate(page))
102 		SetPageUptodate(page);
103 	f2fs_put_page(ipage, 1);
104 	unlock_page(page);
105 	return 0;
106 }
107 
108 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
109 {
110 	struct f2fs_io_info fio = {
111 		.sbi = F2FS_I_SB(dn->inode),
112 		.type = DATA,
113 		.op = REQ_OP_WRITE,
114 		.op_flags = WRITE_SYNC | REQ_PRIO,
115 		.page = page,
116 		.encrypted_page = NULL,
117 	};
118 	int dirty, err;
119 
120 	if (!f2fs_exist_data(dn->inode))
121 		goto clear_out;
122 
123 	err = f2fs_reserve_block(dn, 0);
124 	if (err)
125 		return err;
126 
127 	f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
128 
129 	read_inline_data(page, dn->inode_page);
130 	set_page_dirty(page);
131 
132 	/* clear dirty state */
133 	dirty = clear_page_dirty_for_io(page);
134 
135 	/* write data page to try to make data consistent */
136 	set_page_writeback(page);
137 	fio.old_blkaddr = dn->data_blkaddr;
138 	write_data_page(dn, &fio);
139 	f2fs_wait_on_page_writeback(page, DATA, true);
140 	if (dirty)
141 		inode_dec_dirty_pages(dn->inode);
142 
143 	/* this converted inline_data should be recovered. */
144 	set_inode_flag(dn->inode, FI_APPEND_WRITE);
145 
146 	/* clear inline data and flag after data writeback */
147 	truncate_inline_inode(dn->inode_page, 0);
148 	clear_inline_node(dn->inode_page);
149 clear_out:
150 	stat_dec_inline_inode(dn->inode);
151 	f2fs_clear_inline_inode(dn->inode);
152 	f2fs_put_dnode(dn);
153 	return 0;
154 }
155 
156 int f2fs_convert_inline_inode(struct inode *inode)
157 {
158 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
159 	struct dnode_of_data dn;
160 	struct page *ipage, *page;
161 	int err = 0;
162 
163 	if (!f2fs_has_inline_data(inode))
164 		return 0;
165 
166 	page = f2fs_grab_cache_page(inode->i_mapping, 0, false);
167 	if (!page)
168 		return -ENOMEM;
169 
170 	f2fs_lock_op(sbi);
171 
172 	ipage = get_node_page(sbi, inode->i_ino);
173 	if (IS_ERR(ipage)) {
174 		err = PTR_ERR(ipage);
175 		goto out;
176 	}
177 
178 	set_new_dnode(&dn, inode, ipage, ipage, 0);
179 
180 	if (f2fs_has_inline_data(inode))
181 		err = f2fs_convert_inline_page(&dn, page);
182 
183 	f2fs_put_dnode(&dn);
184 out:
185 	f2fs_unlock_op(sbi);
186 
187 	f2fs_put_page(page, 1);
188 
189 	f2fs_balance_fs(sbi, dn.node_changed);
190 
191 	return err;
192 }
193 
194 int f2fs_write_inline_data(struct inode *inode, struct page *page)
195 {
196 	void *src_addr, *dst_addr;
197 	struct dnode_of_data dn;
198 	int err;
199 
200 	set_new_dnode(&dn, inode, NULL, NULL, 0);
201 	err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
202 	if (err)
203 		return err;
204 
205 	if (!f2fs_has_inline_data(inode)) {
206 		f2fs_put_dnode(&dn);
207 		return -EAGAIN;
208 	}
209 
210 	f2fs_bug_on(F2FS_I_SB(inode), page->index);
211 
212 	f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
213 	src_addr = kmap_atomic(page);
214 	dst_addr = inline_data_addr(dn.inode_page);
215 	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
216 	kunmap_atomic(src_addr);
217 	set_page_dirty(dn.inode_page);
218 
219 	set_inode_flag(inode, FI_APPEND_WRITE);
220 	set_inode_flag(inode, FI_DATA_EXIST);
221 
222 	clear_inline_node(dn.inode_page);
223 	f2fs_put_dnode(&dn);
224 	return 0;
225 }
226 
227 bool recover_inline_data(struct inode *inode, struct page *npage)
228 {
229 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
230 	struct f2fs_inode *ri = NULL;
231 	void *src_addr, *dst_addr;
232 	struct page *ipage;
233 
234 	/*
235 	 * The inline_data recovery policy is as follows.
236 	 * [prev.] [next] of inline_data flag
237 	 *    o       o  -> recover inline_data
238 	 *    o       x  -> remove inline_data, and then recover data blocks
239 	 *    x       o  -> remove inline_data, and then recover inline_data
240 	 *    x       x  -> recover data blocks
241 	 */
242 	if (IS_INODE(npage))
243 		ri = F2FS_INODE(npage);
244 
245 	if (f2fs_has_inline_data(inode) &&
246 			ri && (ri->i_inline & F2FS_INLINE_DATA)) {
247 process_inline:
248 		ipage = get_node_page(sbi, inode->i_ino);
249 		f2fs_bug_on(sbi, IS_ERR(ipage));
250 
251 		f2fs_wait_on_page_writeback(ipage, NODE, true);
252 
253 		src_addr = inline_data_addr(npage);
254 		dst_addr = inline_data_addr(ipage);
255 		memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
256 
257 		set_inode_flag(inode, FI_INLINE_DATA);
258 		set_inode_flag(inode, FI_DATA_EXIST);
259 
260 		set_page_dirty(ipage);
261 		f2fs_put_page(ipage, 1);
262 		return true;
263 	}
264 
265 	if (f2fs_has_inline_data(inode)) {
266 		ipage = get_node_page(sbi, inode->i_ino);
267 		f2fs_bug_on(sbi, IS_ERR(ipage));
268 		if (!truncate_inline_inode(ipage, 0))
269 			return false;
270 		f2fs_clear_inline_inode(inode);
271 		f2fs_put_page(ipage, 1);
272 	} else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
273 		if (truncate_blocks(inode, 0, false))
274 			return false;
275 		goto process_inline;
276 	}
277 	return false;
278 }
279 
280 struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
281 			struct fscrypt_name *fname, struct page **res_page)
282 {
283 	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
284 	struct f2fs_inline_dentry *inline_dentry;
285 	struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
286 	struct f2fs_dir_entry *de;
287 	struct f2fs_dentry_ptr d;
288 	struct page *ipage;
289 	f2fs_hash_t namehash;
290 
291 	ipage = get_node_page(sbi, dir->i_ino);
292 	if (IS_ERR(ipage)) {
293 		*res_page = ipage;
294 		return NULL;
295 	}
296 
297 	namehash = f2fs_dentry_hash(&name);
298 
299 	inline_dentry = inline_data_addr(ipage);
300 
301 	make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
302 	de = find_target_dentry(fname, namehash, NULL, &d);
303 	unlock_page(ipage);
304 	if (de)
305 		*res_page = ipage;
306 	else
307 		f2fs_put_page(ipage, 0);
308 
309 	return de;
310 }
311 
312 int make_empty_inline_dir(struct inode *inode, struct inode *parent,
313 							struct page *ipage)
314 {
315 	struct f2fs_inline_dentry *dentry_blk;
316 	struct f2fs_dentry_ptr d;
317 
318 	dentry_blk = inline_data_addr(ipage);
319 
320 	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
321 	do_make_empty_dir(inode, parent, &d);
322 
323 	set_page_dirty(ipage);
324 
325 	/* update i_size to MAX_INLINE_DATA */
326 	if (i_size_read(inode) < MAX_INLINE_DATA)
327 		f2fs_i_size_write(inode, MAX_INLINE_DATA);
328 	return 0;
329 }
330 
331 /*
332  * NOTE: ipage is grabbed by caller, but if any error occurs, we should
333  * release ipage in this function.
334  */
335 static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
336 				struct f2fs_inline_dentry *inline_dentry)
337 {
338 	struct page *page;
339 	struct dnode_of_data dn;
340 	struct f2fs_dentry_block *dentry_blk;
341 	int err;
342 
343 	page = f2fs_grab_cache_page(dir->i_mapping, 0, false);
344 	if (!page) {
345 		f2fs_put_page(ipage, 1);
346 		return -ENOMEM;
347 	}
348 
349 	set_new_dnode(&dn, dir, ipage, NULL, 0);
350 	err = f2fs_reserve_block(&dn, 0);
351 	if (err)
352 		goto out;
353 
354 	f2fs_wait_on_page_writeback(page, DATA, true);
355 	zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);
356 
357 	dentry_blk = kmap_atomic(page);
358 
359 	/* copy data from inline dentry block to new dentry block */
360 	memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,
361 					INLINE_DENTRY_BITMAP_SIZE);
362 	memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0,
363 			SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE);
364 	/*
365 	 * we do not need to zero out remainder part of dentry and filename
366 	 * field, since we have used bitmap for marking the usage status of
367 	 * them, besides, we can also ignore copying/zeroing reserved space
368 	 * of dentry block, because them haven't been used so far.
369 	 */
370 	memcpy(dentry_blk->dentry, inline_dentry->dentry,
371 			sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);
372 	memcpy(dentry_blk->filename, inline_dentry->filename,
373 					NR_INLINE_DENTRY * F2FS_SLOT_LEN);
374 
375 	kunmap_atomic(dentry_blk);
376 	if (!PageUptodate(page))
377 		SetPageUptodate(page);
378 	set_page_dirty(page);
379 
380 	/* clear inline dir and flag after data writeback */
381 	truncate_inline_inode(ipage, 0);
382 
383 	stat_dec_inline_dir(dir);
384 	clear_inode_flag(dir, FI_INLINE_DENTRY);
385 
386 	f2fs_i_depth_write(dir, 1);
387 	if (i_size_read(dir) < PAGE_SIZE)
388 		f2fs_i_size_write(dir, PAGE_SIZE);
389 out:
390 	f2fs_put_page(page, 1);
391 	return err;
392 }
393 
394 static int f2fs_add_inline_entries(struct inode *dir,
395 			struct f2fs_inline_dentry *inline_dentry)
396 {
397 	struct f2fs_dentry_ptr d;
398 	unsigned long bit_pos = 0;
399 	int err = 0;
400 
401 	make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
402 
403 	while (bit_pos < d.max) {
404 		struct f2fs_dir_entry *de;
405 		struct qstr new_name;
406 		nid_t ino;
407 		umode_t fake_mode;
408 
409 		if (!test_bit_le(bit_pos, d.bitmap)) {
410 			bit_pos++;
411 			continue;
412 		}
413 
414 		de = &d.dentry[bit_pos];
415 
416 		if (unlikely(!de->name_len)) {
417 			bit_pos++;
418 			continue;
419 		}
420 
421 		new_name.name = d.filename[bit_pos];
422 		new_name.len = de->name_len;
423 
424 		ino = le32_to_cpu(de->ino);
425 		fake_mode = get_de_type(de) << S_SHIFT;
426 
427 		err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL,
428 							ino, fake_mode);
429 		if (err)
430 			goto punch_dentry_pages;
431 
432 		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
433 	}
434 	return 0;
435 punch_dentry_pages:
436 	truncate_inode_pages(&dir->i_data, 0);
437 	truncate_blocks(dir, 0, false);
438 	remove_dirty_inode(dir);
439 	return err;
440 }
441 
442 static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
443 				struct f2fs_inline_dentry *inline_dentry)
444 {
445 	struct f2fs_inline_dentry *backup_dentry;
446 	int err;
447 
448 	backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
449 			sizeof(struct f2fs_inline_dentry), GFP_F2FS_ZERO);
450 	if (!backup_dentry) {
451 		f2fs_put_page(ipage, 1);
452 		return -ENOMEM;
453 	}
454 
455 	memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA);
456 	truncate_inline_inode(ipage, 0);
457 
458 	unlock_page(ipage);
459 
460 	err = f2fs_add_inline_entries(dir, backup_dentry);
461 	if (err)
462 		goto recover;
463 
464 	lock_page(ipage);
465 
466 	stat_dec_inline_dir(dir);
467 	clear_inode_flag(dir, FI_INLINE_DENTRY);
468 	kfree(backup_dentry);
469 	return 0;
470 recover:
471 	lock_page(ipage);
472 	memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA);
473 	f2fs_i_depth_write(dir, 0);
474 	f2fs_i_size_write(dir, MAX_INLINE_DATA);
475 	set_page_dirty(ipage);
476 	f2fs_put_page(ipage, 1);
477 
478 	kfree(backup_dentry);
479 	return err;
480 }
481 
482 static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
483 				struct f2fs_inline_dentry *inline_dentry)
484 {
485 	if (!F2FS_I(dir)->i_dir_level)
486 		return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
487 	else
488 		return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
489 }
490 
491 int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
492 				const struct qstr *orig_name,
493 				struct inode *inode, nid_t ino, umode_t mode)
494 {
495 	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
496 	struct page *ipage;
497 	unsigned int bit_pos;
498 	f2fs_hash_t name_hash;
499 	struct f2fs_inline_dentry *dentry_blk = NULL;
500 	struct f2fs_dentry_ptr d;
501 	int slots = GET_DENTRY_SLOTS(new_name->len);
502 	struct page *page = NULL;
503 	int err = 0;
504 
505 	ipage = get_node_page(sbi, dir->i_ino);
506 	if (IS_ERR(ipage))
507 		return PTR_ERR(ipage);
508 
509 	dentry_blk = inline_data_addr(ipage);
510 	bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
511 						slots, NR_INLINE_DENTRY);
512 	if (bit_pos >= NR_INLINE_DENTRY) {
513 		err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);
514 		if (err)
515 			return err;
516 		err = -EAGAIN;
517 		goto out;
518 	}
519 
520 	if (inode) {
521 		down_write(&F2FS_I(inode)->i_sem);
522 		page = init_inode_metadata(inode, dir, new_name,
523 						orig_name, ipage);
524 		if (IS_ERR(page)) {
525 			err = PTR_ERR(page);
526 			goto fail;
527 		}
528 		if (f2fs_encrypted_inode(dir))
529 			file_set_enc_name(inode);
530 	}
531 
532 	f2fs_wait_on_page_writeback(ipage, NODE, true);
533 
534 	name_hash = f2fs_dentry_hash(new_name);
535 	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
536 	f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
537 
538 	set_page_dirty(ipage);
539 
540 	/* we don't need to mark_inode_dirty now */
541 	if (inode) {
542 		f2fs_i_pino_write(inode, dir->i_ino);
543 		f2fs_put_page(page, 1);
544 	}
545 
546 	update_parent_metadata(dir, inode, 0);
547 fail:
548 	if (inode)
549 		up_write(&F2FS_I(inode)->i_sem);
550 out:
551 	f2fs_put_page(ipage, 1);
552 	return err;
553 }
554 
555 void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
556 					struct inode *dir, struct inode *inode)
557 {
558 	struct f2fs_inline_dentry *inline_dentry;
559 	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
560 	unsigned int bit_pos;
561 	int i;
562 
563 	lock_page(page);
564 	f2fs_wait_on_page_writeback(page, NODE, true);
565 
566 	inline_dentry = inline_data_addr(page);
567 	bit_pos = dentry - inline_dentry->dentry;
568 	for (i = 0; i < slots; i++)
569 		__clear_bit_le(bit_pos + i,
570 				&inline_dentry->dentry_bitmap);
571 
572 	set_page_dirty(page);
573 	f2fs_put_page(page, 1);
574 
575 	dir->i_ctime = dir->i_mtime = current_time(dir);
576 	f2fs_mark_inode_dirty_sync(dir);
577 
578 	if (inode)
579 		f2fs_drop_nlink(dir, inode);
580 }
581 
582 bool f2fs_empty_inline_dir(struct inode *dir)
583 {
584 	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
585 	struct page *ipage;
586 	unsigned int bit_pos = 2;
587 	struct f2fs_inline_dentry *dentry_blk;
588 
589 	ipage = get_node_page(sbi, dir->i_ino);
590 	if (IS_ERR(ipage))
591 		return false;
592 
593 	dentry_blk = inline_data_addr(ipage);
594 	bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
595 					NR_INLINE_DENTRY,
596 					bit_pos);
597 
598 	f2fs_put_page(ipage, 1);
599 
600 	if (bit_pos < NR_INLINE_DENTRY)
601 		return false;
602 
603 	return true;
604 }
605 
606 int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
607 				struct fscrypt_str *fstr)
608 {
609 	struct inode *inode = file_inode(file);
610 	struct f2fs_inline_dentry *inline_dentry = NULL;
611 	struct page *ipage = NULL;
612 	struct f2fs_dentry_ptr d;
613 
614 	if (ctx->pos == NR_INLINE_DENTRY)
615 		return 0;
616 
617 	ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
618 	if (IS_ERR(ipage))
619 		return PTR_ERR(ipage);
620 
621 	inline_dentry = inline_data_addr(ipage);
622 
623 	make_dentry_ptr(inode, &d, (void *)inline_dentry, 2);
624 
625 	if (!f2fs_fill_dentries(ctx, &d, 0, fstr))
626 		ctx->pos = NR_INLINE_DENTRY;
627 
628 	f2fs_put_page(ipage, 1);
629 	return 0;
630 }
631 
632 int f2fs_inline_data_fiemap(struct inode *inode,
633 		struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
634 {
635 	__u64 byteaddr, ilen;
636 	__u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
637 		FIEMAP_EXTENT_LAST;
638 	struct node_info ni;
639 	struct page *ipage;
640 	int err = 0;
641 
642 	ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
643 	if (IS_ERR(ipage))
644 		return PTR_ERR(ipage);
645 
646 	if (!f2fs_has_inline_data(inode)) {
647 		err = -EAGAIN;
648 		goto out;
649 	}
650 
651 	ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));
652 	if (start >= ilen)
653 		goto out;
654 	if (start + len < ilen)
655 		ilen = start + len;
656 	ilen -= start;
657 
658 	get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
659 	byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
660 	byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);
661 	err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
662 out:
663 	f2fs_put_page(ipage, 1);
664 	return err;
665 }
666