2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
24 * This file implements UBIFS journal.
26 * The journal consists of 2 parts - the log and bud LEBs. The log has fixed
27 * length and position, while a bud logical eraseblock is any LEB in the main
28 * area. Buds contain file system data - data nodes, inode nodes, etc. The log
29 * contains only references to buds and some other stuff like commit
30 * start node. The idea is that when we commit the journal, we do
31 * not copy the data, the buds just become indexed. Since after the commit the
32 * nodes in bud eraseblocks become leaf nodes of the file system index tree, we
33 * use term "bud". Analogy is obvious, bud eraseblocks contain nodes which will
34 * become leafs in the future.
36 * The journal is multi-headed because we want to write data to the journal as
37 * optimally as possible. It is nice to have nodes belonging to the same inode
38 * in one LEB, so we may write data owned by different inodes to different
39 * journal heads, although at present only one data head is used.
41 * For recovery reasons, the base head contains all inode nodes, all directory
42 * entry nodes and all truncate nodes. This means that the other heads contain
45 * Bud LEBs may be half-indexed. For example, if the bud was not full at the
46 * time of commit, the bud is retained to continue to be used in the journal,
47 * even though the "front" of the LEB is now indexed. In that case, the log
48 * reference contains the offset where the bud starts for the purposes of the
51 * The journal size has to be limited, because the larger is the journal, the
52 * longer it takes to mount UBIFS (scanning the journal) and the more memory it
53 * takes (indexing in the TNC).
55 * All the journal write operations like 'ubifs_jnl_update()' here, which write
56 * multiple UBIFS nodes to the journal at one go, are atomic with respect to
57 * unclean reboots. Should the unclean reboot happen, the recovery code drops
64 * zero_ino_node_unused - zero out unused fields of an on-flash inode node.
65 * @ino: the inode to zero out
67 static inline void zero_ino_node_unused(struct ubifs_ino_node
*ino
)
69 memset(ino
->padding1
, 0, 4);
70 memset(ino
->padding2
, 0, 26);
74 * zero_dent_node_unused - zero out unused fields of an on-flash directory
76 * @dent: the directory entry to zero out
78 static inline void zero_dent_node_unused(struct ubifs_dent_node
*dent
)
81 memset(dent
->padding2
, 0, 4);
85 * zero_data_node_unused - zero out unused fields of an on-flash data node.
86 * @data: the data node to zero out
88 static inline void zero_data_node_unused(struct ubifs_data_node
*data
)
90 memset(data
->padding
, 0, 2);
94 * zero_trun_node_unused - zero out unused fields of an on-flash truncation
96 * @trun: the truncation node to zero out
98 static inline void zero_trun_node_unused(struct ubifs_trun_node
*trun
)
100 memset(trun
->padding
, 0, 12);
104 * reserve_space - reserve space in the journal.
105 * @c: UBIFS file-system description object
106 * @jhead: journal head number
109 * This function reserves space in journal head @head. If the reservation
110 * succeeded, the journal head stays locked and later has to be unlocked using
111 * 'release_head()'. 'write_node()' and 'write_head()' functions also unlock
112 * it. Returns zero in case of success, %-EAGAIN if commit has to be done, and
113 * other negative error codes in case of other failures.
115 static int reserve_space(struct ubifs_info
*c
, int jhead
, int len
)
117 int err
= 0, err1
, retries
= 0, avail
, lnum
, offs
, free
, squeeze
;
118 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
121 * Typically, the base head has smaller nodes written to it, so it is
122 * better to try to allocate space at the ends of eraseblocks. This is
123 * what the squeeze parameter does.
125 squeeze
= (jhead
== BASEHD
);
127 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
134 avail
= c
->leb_size
- wbuf
->offs
- wbuf
->used
;
135 if (wbuf
->lnum
!= -1 && avail
>= len
)
139 * Write buffer wasn't seek'ed or there is no enough space - look for an
140 * LEB with some empty space.
142 lnum
= ubifs_find_free_space(c
, len
, &free
, squeeze
);
144 /* Found an LEB, add it to the journal head */
145 offs
= c
->leb_size
- free
;
146 err
= ubifs_add_bud_to_log(c
, jhead
, lnum
, offs
);
149 /* A new bud was successfully allocated and added to the log */
158 * No free space, we have to run garbage collector to make
159 * some. But the write-buffer mutex has to be unlocked because
162 dbg_jnl("no free space jhead %d, run GC", jhead
);
163 mutex_unlock(&wbuf
->io_mutex
);
165 lnum
= ubifs_garbage_collect(c
, 0);
172 * GC could not make a free LEB. But someone else may
173 * have allocated new bud for this journal head,
174 * because we dropped @wbuf->io_mutex, so try once
177 dbg_jnl("GC couldn't make a free LEB for jhead %d", jhead
);
179 dbg_jnl("retry (%d)", retries
);
183 dbg_jnl("return -ENOSPC");
187 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
188 dbg_jnl("got LEB %d for jhead %d", lnum
, jhead
);
189 avail
= c
->leb_size
- wbuf
->offs
- wbuf
->used
;
191 if (wbuf
->lnum
!= -1 && avail
>= len
) {
193 * Someone else has switched the journal head and we have
194 * enough space now. This happens when more then one process is
195 * trying to write to the same journal head at the same time.
197 dbg_jnl("return LEB %d back, already have LEB %d:%d",
198 lnum
, wbuf
->lnum
, wbuf
->offs
+ wbuf
->used
);
199 err
= ubifs_return_leb(c
, lnum
);
205 err
= ubifs_add_bud_to_log(c
, jhead
, lnum
, 0);
211 err
= ubifs_wbuf_seek_nolock(wbuf
, lnum
, offs
, UBI_SHORTTERM
);
218 mutex_unlock(&wbuf
->io_mutex
);
222 /* An error occurred and the LEB has to be returned to lprops */
223 ubifs_assert(err
< 0);
224 err1
= ubifs_return_leb(c
, lnum
);
225 if (err1
&& err
== -EAGAIN
)
227 * Return original error code only if it is not %-EAGAIN,
228 * which is not really an error. Otherwise, return the error
229 * code of 'ubifs_return_leb()'.
232 mutex_unlock(&wbuf
->io_mutex
);
237 * write_node - write node to a journal head.
238 * @c: UBIFS file-system description object
239 * @jhead: journal head
240 * @node: node to write
242 * @lnum: LEB number written is returned here
243 * @offs: offset written is returned here
245 * This function writes a node to reserved space of journal head @jhead.
246 * Returns zero in case of success and a negative error code in case of
249 static int write_node(struct ubifs_info
*c
, int jhead
, void *node
, int len
,
250 int *lnum
, int *offs
)
252 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
254 ubifs_assert(jhead
!= GCHD
);
256 *lnum
= c
->jheads
[jhead
].wbuf
.lnum
;
257 *offs
= c
->jheads
[jhead
].wbuf
.offs
+ c
->jheads
[jhead
].wbuf
.used
;
259 dbg_jnl("jhead %d, LEB %d:%d, len %d", jhead
, *lnum
, *offs
, len
);
260 ubifs_prepare_node(c
, node
, len
, 0);
262 return ubifs_wbuf_write_nolock(wbuf
, node
, len
);
266 * write_head - write data to a journal head.
267 * @c: UBIFS file-system description object
268 * @jhead: journal head
269 * @buf: buffer to write
270 * @len: length to write
271 * @lnum: LEB number written is returned here
272 * @offs: offset written is returned here
273 * @sync: non-zero if the write-buffer has to by synchronized
275 * This function is the same as 'write_node()' but it does not assume the
276 * buffer it is writing is a node, so it does not prepare it (which means
277 * initializing common header and calculating CRC).
279 static int write_head(struct ubifs_info
*c
, int jhead
, void *buf
, int len
,
280 int *lnum
, int *offs
, int sync
)
283 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
285 ubifs_assert(jhead
!= GCHD
);
287 *lnum
= c
->jheads
[jhead
].wbuf
.lnum
;
288 *offs
= c
->jheads
[jhead
].wbuf
.offs
+ c
->jheads
[jhead
].wbuf
.used
;
289 dbg_jnl("jhead %d, LEB %d:%d, len %d", jhead
, *lnum
, *offs
, len
);
291 err
= ubifs_wbuf_write_nolock(wbuf
, buf
, len
);
295 err
= ubifs_wbuf_sync_nolock(wbuf
);
300 * make_reservation - reserve journal space.
301 * @c: UBIFS file-system description object
302 * @jhead: journal head
303 * @len: how many bytes to reserve
305 * This function makes space reservation in journal head @jhead. The function
306 * takes the commit lock and locks the journal head, and the caller has to
307 * unlock the head and finish the reservation with 'finish_reservation()'.
308 * Returns zero in case of success and a negative error code in case of
311 * Note, the journal head may be unlocked as soon as the data is written, while
312 * the commit lock has to be released after the data has been added to the
315 static int make_reservation(struct ubifs_info
*c
, int jhead
, int len
)
317 int err
, cmt_retries
= 0, nospc_retries
= 0;
320 down_read(&c
->commit_sem
);
321 err
= reserve_space(c
, jhead
, len
);
324 up_read(&c
->commit_sem
);
326 if (err
== -ENOSPC
) {
328 * GC could not make any progress. We should try to commit
329 * once because it could make some dirty space and GC would
330 * make progress, so make the error -EAGAIN so that the below
331 * will commit and re-try.
333 if (nospc_retries
++ < 2) {
334 dbg_jnl("no space, retry");
339 * This means that the budgeting is incorrect. We always have
340 * to be able to write to the media, because all operations are
341 * budgeted. Deletions are not budgeted, though, but we reserve
342 * an extra LEB for them.
350 * -EAGAIN means that the journal is full or too large, or the above
351 * code wants to do one commit. Do this and re-try.
353 if (cmt_retries
> 128) {
355 * This should not happen unless the journal size limitations
358 ubifs_err("stuck in space allocation");
361 } else if (cmt_retries
> 32)
362 ubifs_warn("too many space allocation re-tries (%d)",
365 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
369 err
= ubifs_run_commit(c
);
375 ubifs_err("cannot reserve %d bytes in jhead %d, error %d",
377 if (err
== -ENOSPC
) {
378 /* This are some budgeting problems, print useful information */
379 down_write(&c
->commit_sem
);
380 spin_lock(&c
->space_lock
);
383 spin_unlock(&c
->space_lock
);
385 cmt_retries
= dbg_check_lprops(c
);
386 up_write(&c
->commit_sem
);
392 * release_head - release a journal head.
393 * @c: UBIFS file-system description object
394 * @jhead: journal head
396 * This function releases journal head @jhead which was locked by
397 * the 'make_reservation()' function. It has to be called after each successful
398 * 'make_reservation()' invocation.
400 static inline void release_head(struct ubifs_info
*c
, int jhead
)
402 mutex_unlock(&c
->jheads
[jhead
].wbuf
.io_mutex
);
406 * finish_reservation - finish a reservation.
407 * @c: UBIFS file-system description object
409 * This function finishes journal space reservation. It must be called after
410 * 'make_reservation()'.
412 static void finish_reservation(struct ubifs_info
*c
)
414 up_read(&c
->commit_sem
);
418 * get_dent_type - translate VFS inode mode to UBIFS directory entry type.
421 static int get_dent_type(int mode
)
423 switch (mode
& S_IFMT
) {
425 return UBIFS_ITYPE_REG
;
427 return UBIFS_ITYPE_DIR
;
429 return UBIFS_ITYPE_LNK
;
431 return UBIFS_ITYPE_BLK
;
433 return UBIFS_ITYPE_CHR
;
435 return UBIFS_ITYPE_FIFO
;
437 return UBIFS_ITYPE_SOCK
;
445 * pack_inode - pack an inode node.
446 * @c: UBIFS file-system description object
447 * @ino: buffer in which to pack inode node
448 * @inode: inode to pack
449 * @last: indicates the last node of the group
451 static void pack_inode(struct ubifs_info
*c
, struct ubifs_ino_node
*ino
,
452 const struct inode
*inode
, int last
)
454 int data_len
= 0, last_reference
= !inode
->i_nlink
;
455 struct ubifs_inode
*ui
= ubifs_inode(inode
);
457 ino
->ch
.node_type
= UBIFS_INO_NODE
;
458 ino_key_init_flash(c
, &ino
->key
, inode
->i_ino
);
459 ino
->creat_sqnum
= cpu_to_le64(ui
->creat_sqnum
);
460 ino
->atime_sec
= cpu_to_le64(inode
->i_atime
.tv_sec
);
461 ino
->atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
462 ino
->ctime_sec
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
463 ino
->ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
464 ino
->mtime_sec
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
465 ino
->mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
466 ino
->uid
= cpu_to_le32(inode
->i_uid
);
467 ino
->gid
= cpu_to_le32(inode
->i_gid
);
468 ino
->mode
= cpu_to_le32(inode
->i_mode
);
469 ino
->flags
= cpu_to_le32(ui
->flags
);
470 ino
->size
= cpu_to_le64(ui
->ui_size
);
471 ino
->nlink
= cpu_to_le32(inode
->i_nlink
);
472 ino
->compr_type
= cpu_to_le16(ui
->compr_type
);
473 ino
->data_len
= cpu_to_le32(ui
->data_len
);
474 ino
->xattr_cnt
= cpu_to_le32(ui
->xattr_cnt
);
475 ino
->xattr_size
= cpu_to_le32(ui
->xattr_size
);
476 ino
->xattr_names
= cpu_to_le32(ui
->xattr_names
);
477 zero_ino_node_unused(ino
);
480 * Drop the attached data if this is a deletion inode, the data is not
483 if (!last_reference
) {
484 memcpy(ino
->data
, ui
->data
, ui
->data_len
);
485 data_len
= ui
->data_len
;
488 ubifs_prep_grp_node(c
, ino
, UBIFS_INO_NODE_SZ
+ data_len
, last
);
492 * mark_inode_clean - mark UBIFS inode as clean.
493 * @c: UBIFS file-system description object
494 * @ui: UBIFS inode to mark as clean
496 * This helper function marks UBIFS inode @ui as clean by cleaning the
497 * @ui->dirty flag and releasing its budget. Note, VFS may still treat the
498 * inode as dirty and try to write it back, but 'ubifs_write_inode()' would
501 static void mark_inode_clean(struct ubifs_info
*c
, struct ubifs_inode
*ui
)
504 ubifs_release_dirty_inode_budget(c
, ui
);
509 * ubifs_jnl_update - update inode.
510 * @c: UBIFS file-system description object
511 * @dir: parent inode or host inode in case of extended attributes
512 * @nm: directory entry name
513 * @inode: inode to update
514 * @deletion: indicates a directory entry deletion i.e unlink or rmdir
515 * @xent: non-zero if the directory entry is an extended attribute entry
517 * This function updates an inode by writing a directory entry (or extended
518 * attribute entry), the inode itself, and the parent directory inode (or the
519 * host inode) to the journal.
521 * The function writes the host inode @dir last, which is important in case of
522 * extended attributes. Indeed, then we guarantee that if the host inode gets
523 * synchronized (with 'fsync()'), and the write-buffer it sits in gets flushed,
524 * the extended attribute inode gets flushed too. And this is exactly what the
525 * user expects - synchronizing the host inode synchronizes its extended
526 * attributes. Similarly, this guarantees that if @dir is synchronized, its
527 * directory entry corresponding to @nm gets synchronized too.
529 * If the inode (@inode) or the parent directory (@dir) are synchronous, this
530 * function synchronizes the write-buffer.
532 * This function marks the @dir and @inode inodes as clean and returns zero on
533 * success. In case of failure, a negative error code is returned.
535 int ubifs_jnl_update(struct ubifs_info
*c
, const struct inode
*dir
,
536 const struct qstr
*nm
, const struct inode
*inode
,
537 int deletion
, int xent
)
539 int err
, dlen
, ilen
, len
, lnum
, ino_offs
, dent_offs
;
540 int aligned_dlen
, aligned_ilen
, sync
= IS_DIRSYNC(dir
);
541 int last_reference
= !!(deletion
&& inode
->i_nlink
== 0);
542 struct ubifs_inode
*ui
= ubifs_inode(inode
);
543 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
544 struct ubifs_dent_node
*dent
;
545 struct ubifs_ino_node
*ino
;
546 union ubifs_key dent_key
, ino_key
;
548 dbg_jnl("ino %lu, dent '%.*s', data len %d in dir ino %lu",
549 inode
->i_ino
, nm
->len
, nm
->name
, ui
->data_len
, dir
->i_ino
);
550 ubifs_assert(dir_ui
->data_len
== 0);
551 ubifs_assert(mutex_is_locked(&dir_ui
->ui_mutex
));
553 dlen
= UBIFS_DENT_NODE_SZ
+ nm
->len
+ 1;
554 ilen
= UBIFS_INO_NODE_SZ
;
557 * If the last reference to the inode is being deleted, then there is
558 * no need to attach and write inode data, it is being deleted anyway.
559 * And if the inode is being deleted, no need to synchronize
560 * write-buffer even if the inode is synchronous.
562 if (!last_reference
) {
563 ilen
+= ui
->data_len
;
564 sync
|= IS_SYNC(inode
);
567 aligned_dlen
= ALIGN(dlen
, 8);
568 aligned_ilen
= ALIGN(ilen
, 8);
569 len
= aligned_dlen
+ aligned_ilen
+ UBIFS_INO_NODE_SZ
;
570 dent
= kmalloc(len
, GFP_NOFS
);
574 /* Make reservation before allocating sequence numbers */
575 err
= make_reservation(c
, BASEHD
, len
);
580 dent
->ch
.node_type
= UBIFS_DENT_NODE
;
581 dent_key_init(c
, &dent_key
, dir
->i_ino
, nm
);
583 dent
->ch
.node_type
= UBIFS_XENT_NODE
;
584 xent_key_init(c
, &dent_key
, dir
->i_ino
, nm
);
587 key_write(c
, &dent_key
, dent
->key
);
588 dent
->inum
= deletion
? 0 : cpu_to_le64(inode
->i_ino
);
589 dent
->type
= get_dent_type(inode
->i_mode
);
590 dent
->nlen
= cpu_to_le16(nm
->len
);
591 memcpy(dent
->name
, nm
->name
, nm
->len
);
592 dent
->name
[nm
->len
] = '\0';
593 zero_dent_node_unused(dent
);
594 ubifs_prep_grp_node(c
, dent
, dlen
, 0);
596 ino
= (void *)dent
+ aligned_dlen
;
597 pack_inode(c
, ino
, inode
, 0);
598 ino
= (void *)ino
+ aligned_ilen
;
599 pack_inode(c
, ino
, dir
, 1);
601 if (last_reference
) {
602 err
= ubifs_add_orphan(c
, inode
->i_ino
);
604 release_head(c
, BASEHD
);
607 ui
->del_cmtno
= c
->cmt_no
;
610 err
= write_head(c
, BASEHD
, dent
, len
, &lnum
, &dent_offs
, sync
);
614 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
616 ubifs_wbuf_add_ino_nolock(wbuf
, inode
->i_ino
);
617 ubifs_wbuf_add_ino_nolock(wbuf
, dir
->i_ino
);
619 release_head(c
, BASEHD
);
623 err
= ubifs_tnc_remove_nm(c
, &dent_key
, nm
);
626 err
= ubifs_add_dirt(c
, lnum
, dlen
);
628 err
= ubifs_tnc_add_nm(c
, &dent_key
, lnum
, dent_offs
, dlen
, nm
);
633 * Note, we do not remove the inode from TNC even if the last reference
634 * to it has just been deleted, because the inode may still be opened.
635 * Instead, the inode has been added to orphan lists and the orphan
636 * subsystem will take further care about it.
638 ino_key_init(c
, &ino_key
, inode
->i_ino
);
639 ino_offs
= dent_offs
+ aligned_dlen
;
640 err
= ubifs_tnc_add(c
, &ino_key
, lnum
, ino_offs
, ilen
);
644 ino_key_init(c
, &ino_key
, dir
->i_ino
);
645 ino_offs
+= aligned_ilen
;
646 err
= ubifs_tnc_add(c
, &ino_key
, lnum
, ino_offs
, UBIFS_INO_NODE_SZ
);
650 finish_reservation(c
);
651 spin_lock(&ui
->ui_lock
);
652 ui
->synced_i_size
= ui
->ui_size
;
653 spin_unlock(&ui
->ui_lock
);
654 mark_inode_clean(c
, ui
);
655 mark_inode_clean(c
, dir_ui
);
659 finish_reservation(c
);
665 release_head(c
, BASEHD
);
667 ubifs_ro_mode(c
, err
);
669 ubifs_delete_orphan(c
, inode
->i_ino
);
670 finish_reservation(c
);
675 * ubifs_jnl_write_data - write a data node to the journal.
676 * @c: UBIFS file-system description object
677 * @inode: inode the data node belongs to
679 * @buf: buffer to write
680 * @len: data length (must not exceed %UBIFS_BLOCK_SIZE)
682 * This function writes a data node to the journal. Returns %0 if the data node
683 * was successfully written, and a negative error code in case of failure.
685 int ubifs_jnl_write_data(struct ubifs_info
*c
, const struct inode
*inode
,
686 const union ubifs_key
*key
, const void *buf
, int len
)
688 struct ubifs_data_node
*data
;
689 int err
, lnum
, offs
, compr_type
, out_len
;
690 int dlen
= UBIFS_DATA_NODE_SZ
+ UBIFS_BLOCK_SIZE
* WORST_COMPR_FACTOR
;
691 struct ubifs_inode
*ui
= ubifs_inode(inode
);
693 dbg_jnl("ino %lu, blk %u, len %d, key %s", key_inum(c
, key
),
694 key_block(c
, key
), len
, DBGKEY(key
));
695 ubifs_assert(len
<= UBIFS_BLOCK_SIZE
);
697 data
= kmalloc(dlen
, GFP_NOFS
);
701 data
->ch
.node_type
= UBIFS_DATA_NODE
;
702 key_write(c
, key
, &data
->key
);
703 data
->size
= cpu_to_le32(len
);
704 zero_data_node_unused(data
);
706 if (!(ui
->flags
&& UBIFS_COMPR_FL
))
707 /* Compression is disabled for this inode */
708 compr_type
= UBIFS_COMPR_NONE
;
710 compr_type
= ui
->compr_type
;
712 out_len
= dlen
- UBIFS_DATA_NODE_SZ
;
713 ubifs_compress(buf
, len
, &data
->data
, &out_len
, &compr_type
);
714 ubifs_assert(out_len
<= UBIFS_BLOCK_SIZE
);
716 dlen
= UBIFS_DATA_NODE_SZ
+ out_len
;
717 data
->compr_type
= cpu_to_le16(compr_type
);
719 /* Make reservation before allocating sequence numbers */
720 err
= make_reservation(c
, DATAHD
, dlen
);
724 err
= write_node(c
, DATAHD
, data
, dlen
, &lnum
, &offs
);
727 ubifs_wbuf_add_ino_nolock(&c
->jheads
[DATAHD
].wbuf
, key_inum(c
, key
));
728 release_head(c
, DATAHD
);
730 err
= ubifs_tnc_add(c
, key
, lnum
, offs
, dlen
);
734 finish_reservation(c
);
739 release_head(c
, DATAHD
);
741 ubifs_ro_mode(c
, err
);
742 finish_reservation(c
);
749 * ubifs_jnl_write_inode - flush inode to the journal.
750 * @c: UBIFS file-system description object
751 * @inode: inode to flush
753 * This function writes inode @inode to the journal. If the inode is
754 * synchronous, it also synchronizes the write-buffer. Returns zero in case of
755 * success and a negative error code in case of failure.
757 int ubifs_jnl_write_inode(struct ubifs_info
*c
, const struct inode
*inode
)
760 struct ubifs_ino_node
*ino
;
761 struct ubifs_inode
*ui
= ubifs_inode(inode
);
762 int sync
= 0, len
= UBIFS_INO_NODE_SZ
, last_reference
= !inode
->i_nlink
;
764 dbg_jnl("ino %lu, nlink %u", inode
->i_ino
, inode
->i_nlink
);
767 * If the inode is being deleted, do not write the attached data. No
768 * need to synchronize the write-buffer either.
770 if (!last_reference
) {
772 sync
= IS_SYNC(inode
);
774 ino
= kmalloc(len
, GFP_NOFS
);
778 /* Make reservation before allocating sequence numbers */
779 err
= make_reservation(c
, BASEHD
, len
);
783 pack_inode(c
, ino
, inode
, 1);
784 err
= write_head(c
, BASEHD
, ino
, len
, &lnum
, &offs
, sync
);
788 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
,
790 release_head(c
, BASEHD
);
792 if (last_reference
) {
793 err
= ubifs_tnc_remove_ino(c
, inode
->i_ino
);
796 ubifs_delete_orphan(c
, inode
->i_ino
);
797 err
= ubifs_add_dirt(c
, lnum
, len
);
801 ino_key_init(c
, &key
, inode
->i_ino
);
802 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, len
);
807 finish_reservation(c
);
808 spin_lock(&ui
->ui_lock
);
809 ui
->synced_i_size
= ui
->ui_size
;
810 spin_unlock(&ui
->ui_lock
);
815 release_head(c
, BASEHD
);
817 ubifs_ro_mode(c
, err
);
818 finish_reservation(c
);
825 * ubifs_jnl_write_inode - delete an inode.
826 * @c: UBIFS file-system description object
827 * @inode: inode to delete
829 * This function deletes inode @inode which includes removing it from orphans,
830 * deleting it from TNC and, in some cases, writing a deletion inode to the
833 * When regular file inodes are unlinked or a directory inode is removed, the
834 * 'ubifs_jnl_update()' function write corresponding deletion inode and
835 * direntry to the media, and adds the inode to orphans. After this, when the
836 * last reference to this inode has been dropped, this function is called. In
837 * general, it has to write one more deletion inode to the media, because if
838 * a commit happened between 'ubifs_jnl_update()' and
839 * 'ubifs_jnl_delete_inode()', the deletion inode is not in the journal
840 * anymore, and in fact it might be not on the flash anymore, becouse it might
841 * have been garbage-collected already. And for optimization reasond UBIFS does
842 * not read the orphan area if it has been unmounted cleanly, so it would have
843 * no indication in the journal that there is a deleted inode which has to be
846 * However, if there was no commit between 'ubifs_jnl_update()' and
847 * 'ubifs_jnl_delete_inode()', then there is no need to write the deletion
848 * inode to the media for the second time. And this is quite typical case.
850 * This function returns zero in case of success and a negative error code in
853 int ubifs_jnl_delete_inode(struct ubifs_info
*c
, const struct inode
*inode
)
856 struct ubifs_inode
*ui
= ubifs_inode(inode
);
858 ubifs_assert(inode
->i_nlink
== 0);
860 if (ui
->del_cmtno
!= c
->cmt_no
)
861 /* A commit happened for sure */
862 return ubifs_jnl_write_inode(c
, inode
);
864 down_read(&c
->commit_sem
);
866 * Check commit number again, because the first test has been done
867 * without @c->commit_sem, so a commit might have happened.
869 if (ui
->del_cmtno
!= c
->cmt_no
) {
870 up_read(&c
->commit_sem
);
871 return ubifs_jnl_write_inode(c
, inode
);
874 ubifs_delete_orphan(c
, inode
->i_ino
);
875 err
= ubifs_tnc_remove_ino(c
, inode
->i_ino
);
877 ubifs_ro_mode(c
, err
);
878 up_read(&c
->commit_sem
);
883 * ubifs_jnl_rename - rename a directory entry.
884 * @c: UBIFS file-system description object
885 * @old_dir: parent inode of directory entry to rename
886 * @old_dentry: directory entry to rename
887 * @new_dir: parent inode of directory entry to rename
888 * @new_dentry: new directory entry (or directory entry to replace)
889 * @sync: non-zero if the write-buffer has to be synchronized
891 * This function implements the re-name operation which may involve writing up
892 * to 3 inodes and 2 directory entries. It marks the written inodes as clean
893 * and returns zero on success. In case of failure, a negative error code is
896 int ubifs_jnl_rename(struct ubifs_info
*c
, const struct inode
*old_dir
,
897 const struct dentry
*old_dentry
,
898 const struct inode
*new_dir
,
899 const struct dentry
*new_dentry
, int sync
)
903 struct ubifs_dent_node
*dent
, *dent2
;
904 int err
, dlen1
, dlen2
, ilen
, lnum
, offs
, len
;
905 const struct inode
*old_inode
= old_dentry
->d_inode
;
906 const struct inode
*new_inode
= new_dentry
->d_inode
;
907 int aligned_dlen1
, aligned_dlen2
, plen
= UBIFS_INO_NODE_SZ
;
908 int last_reference
= !!(new_inode
&& new_inode
->i_nlink
== 0);
909 int move
= (old_dir
!= new_dir
);
910 struct ubifs_inode
*uninitialized_var(new_ui
);
912 dbg_jnl("dent '%.*s' in dir ino %lu to dent '%.*s' in dir ino %lu",
913 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
914 old_dir
->i_ino
, new_dentry
->d_name
.len
,
915 new_dentry
->d_name
.name
, new_dir
->i_ino
);
916 ubifs_assert(ubifs_inode(old_dir
)->data_len
== 0);
917 ubifs_assert(ubifs_inode(new_dir
)->data_len
== 0);
918 ubifs_assert(mutex_is_locked(&ubifs_inode(old_dir
)->ui_mutex
));
919 ubifs_assert(mutex_is_locked(&ubifs_inode(new_dir
)->ui_mutex
));
921 dlen1
= UBIFS_DENT_NODE_SZ
+ new_dentry
->d_name
.len
+ 1;
922 dlen2
= UBIFS_DENT_NODE_SZ
+ old_dentry
->d_name
.len
+ 1;
924 new_ui
= ubifs_inode(new_inode
);
925 ubifs_assert(mutex_is_locked(&new_ui
->ui_mutex
));
926 ilen
= UBIFS_INO_NODE_SZ
;
928 ilen
+= new_ui
->data_len
;
932 aligned_dlen1
= ALIGN(dlen1
, 8);
933 aligned_dlen2
= ALIGN(dlen2
, 8);
934 len
= aligned_dlen1
+ aligned_dlen2
+ ALIGN(ilen
, 8) + ALIGN(plen
, 8);
935 if (old_dir
!= new_dir
)
937 dent
= kmalloc(len
, GFP_NOFS
);
941 /* Make reservation before allocating sequence numbers */
942 err
= make_reservation(c
, BASEHD
, len
);
947 dent
->ch
.node_type
= UBIFS_DENT_NODE
;
948 dent_key_init_flash(c
, &dent
->key
, new_dir
->i_ino
, &new_dentry
->d_name
);
949 dent
->inum
= cpu_to_le64(old_inode
->i_ino
);
950 dent
->type
= get_dent_type(old_inode
->i_mode
);
951 dent
->nlen
= cpu_to_le16(new_dentry
->d_name
.len
);
952 memcpy(dent
->name
, new_dentry
->d_name
.name
, new_dentry
->d_name
.len
);
953 dent
->name
[new_dentry
->d_name
.len
] = '\0';
954 zero_dent_node_unused(dent
);
955 ubifs_prep_grp_node(c
, dent
, dlen1
, 0);
957 /* Make deletion dent */
958 dent2
= (void *)dent
+ aligned_dlen1
;
959 dent2
->ch
.node_type
= UBIFS_DENT_NODE
;
960 dent_key_init_flash(c
, &dent2
->key
, old_dir
->i_ino
,
961 &old_dentry
->d_name
);
963 dent2
->type
= DT_UNKNOWN
;
964 dent2
->nlen
= cpu_to_le16(old_dentry
->d_name
.len
);
965 memcpy(dent2
->name
, old_dentry
->d_name
.name
, old_dentry
->d_name
.len
);
966 dent2
->name
[old_dentry
->d_name
.len
] = '\0';
967 zero_dent_node_unused(dent2
);
968 ubifs_prep_grp_node(c
, dent2
, dlen2
, 0);
970 p
= (void *)dent2
+ aligned_dlen2
;
972 pack_inode(c
, p
, new_inode
, 0);
977 pack_inode(c
, p
, old_dir
, 1);
979 pack_inode(c
, p
, old_dir
, 0);
981 pack_inode(c
, p
, new_dir
, 1);
984 if (last_reference
) {
985 err
= ubifs_add_orphan(c
, new_inode
->i_ino
);
987 release_head(c
, BASEHD
);
990 new_ui
->del_cmtno
= c
->cmt_no
;
993 err
= write_head(c
, BASEHD
, dent
, len
, &lnum
, &offs
, sync
);
997 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
999 ubifs_wbuf_add_ino_nolock(wbuf
, new_dir
->i_ino
);
1000 ubifs_wbuf_add_ino_nolock(wbuf
, old_dir
->i_ino
);
1002 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
,
1005 release_head(c
, BASEHD
);
1007 dent_key_init(c
, &key
, new_dir
->i_ino
, &new_dentry
->d_name
);
1008 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen1
, &new_dentry
->d_name
);
1012 err
= ubifs_add_dirt(c
, lnum
, dlen2
);
1016 dent_key_init(c
, &key
, old_dir
->i_ino
, &old_dentry
->d_name
);
1017 err
= ubifs_tnc_remove_nm(c
, &key
, &old_dentry
->d_name
);
1021 offs
+= aligned_dlen1
+ aligned_dlen2
;
1023 ino_key_init(c
, &key
, new_inode
->i_ino
);
1024 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, ilen
);
1027 offs
+= ALIGN(ilen
, 8);
1030 ino_key_init(c
, &key
, old_dir
->i_ino
);
1031 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
);
1035 if (old_dir
!= new_dir
) {
1036 offs
+= ALIGN(plen
, 8);
1037 ino_key_init(c
, &key
, new_dir
->i_ino
);
1038 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
);
1043 finish_reservation(c
);
1045 mark_inode_clean(c
, new_ui
);
1046 spin_lock(&new_ui
->ui_lock
);
1047 new_ui
->synced_i_size
= new_ui
->ui_size
;
1048 spin_unlock(&new_ui
->ui_lock
);
1050 mark_inode_clean(c
, ubifs_inode(old_dir
));
1052 mark_inode_clean(c
, ubifs_inode(new_dir
));
1057 release_head(c
, BASEHD
);
1059 ubifs_ro_mode(c
, err
);
1061 ubifs_delete_orphan(c
, new_inode
->i_ino
);
1063 finish_reservation(c
);
1070 * recomp_data_node - re-compress a truncated data node.
1071 * @dn: data node to re-compress
1072 * @new_len: new length
1074 * This function is used when an inode is truncated and the last data node of
1075 * the inode has to be re-compressed and re-written.
1077 static int recomp_data_node(struct ubifs_data_node
*dn
, int *new_len
)
1080 int err
, len
, compr_type
, out_len
;
1082 out_len
= le32_to_cpu(dn
->size
);
1083 buf
= kmalloc(out_len
* WORST_COMPR_FACTOR
, GFP_NOFS
);
1087 len
= le32_to_cpu(dn
->ch
.len
) - UBIFS_DATA_NODE_SZ
;
1088 compr_type
= le16_to_cpu(dn
->compr_type
);
1089 err
= ubifs_decompress(&dn
->data
, len
, buf
, &out_len
, compr_type
);
1093 ubifs_compress(buf
, *new_len
, &dn
->data
, &out_len
, &compr_type
);
1094 ubifs_assert(out_len
<= UBIFS_BLOCK_SIZE
);
1095 dn
->compr_type
= cpu_to_le16(compr_type
);
1096 dn
->size
= cpu_to_le32(*new_len
);
1097 *new_len
= UBIFS_DATA_NODE_SZ
+ out_len
;
1104 * ubifs_jnl_truncate - update the journal for a truncation.
1105 * @c: UBIFS file-system description object
1106 * @inode: inode to truncate
1107 * @old_size: old size
1108 * @new_size: new size
1110 * When the size of a file decreases due to truncation, a truncation node is
1111 * written, the journal tree is updated, and the last data block is re-written
1112 * if it has been affected. The inode is also updated in order to synchronize
1113 * the new inode size.
1115 * This function marks the inode as clean and returns zero on success. In case
1116 * of failure, a negative error code is returned.
1118 int ubifs_jnl_truncate(struct ubifs_info
*c
, const struct inode
*inode
,
1119 loff_t old_size
, loff_t new_size
)
1121 union ubifs_key key
, to_key
;
1122 struct ubifs_ino_node
*ino
;
1123 struct ubifs_trun_node
*trun
;
1124 struct ubifs_data_node
*uninitialized_var(dn
);
1125 int err
, dlen
, len
, lnum
, offs
, bit
, sz
, sync
= IS_SYNC(inode
);
1126 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1127 ino_t inum
= inode
->i_ino
;
1130 dbg_jnl("ino %lu, size %lld -> %lld", inum
, old_size
, new_size
);
1131 ubifs_assert(!ui
->data_len
);
1132 ubifs_assert(S_ISREG(inode
->i_mode
));
1133 ubifs_assert(mutex_is_locked(&ui
->ui_mutex
));
1135 sz
= UBIFS_TRUN_NODE_SZ
+ UBIFS_INO_NODE_SZ
+
1136 UBIFS_MAX_DATA_NODE_SZ
* WORST_COMPR_FACTOR
;
1137 ino
= kmalloc(sz
, GFP_NOFS
);
1141 trun
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
1142 trun
->ch
.node_type
= UBIFS_TRUN_NODE
;
1143 trun
->inum
= cpu_to_le32(inum
);
1144 trun
->old_size
= cpu_to_le64(old_size
);
1145 trun
->new_size
= cpu_to_le64(new_size
);
1146 zero_trun_node_unused(trun
);
1148 dlen
= new_size
& (UBIFS_BLOCK_SIZE
- 1);
1150 /* Get last data block so it can be truncated */
1151 dn
= (void *)trun
+ UBIFS_TRUN_NODE_SZ
;
1152 blk
= new_size
>> UBIFS_BLOCK_SHIFT
;
1153 data_key_init(c
, &key
, inum
, blk
);
1154 dbg_jnl("last block key %s", DBGKEY(&key
));
1155 err
= ubifs_tnc_lookup(c
, &key
, dn
);
1157 dlen
= 0; /* Not found (so it is a hole) */
1161 if (le32_to_cpu(dn
->size
) <= dlen
)
1162 dlen
= 0; /* Nothing to do */
1164 int compr_type
= le16_to_cpu(dn
->compr_type
);
1166 if (compr_type
!= UBIFS_COMPR_NONE
) {
1167 err
= recomp_data_node(dn
, &dlen
);
1171 dn
->size
= cpu_to_le32(dlen
);
1172 dlen
+= UBIFS_DATA_NODE_SZ
;
1174 zero_data_node_unused(dn
);
1179 /* Must make reservation before allocating sequence numbers */
1180 len
= UBIFS_TRUN_NODE_SZ
+ UBIFS_INO_NODE_SZ
;
1183 err
= make_reservation(c
, BASEHD
, len
);
1187 pack_inode(c
, ino
, inode
, 0);
1188 ubifs_prep_grp_node(c
, trun
, UBIFS_TRUN_NODE_SZ
, dlen
? 0 : 1);
1190 ubifs_prep_grp_node(c
, dn
, dlen
, 1);
1192 err
= write_head(c
, BASEHD
, ino
, len
, &lnum
, &offs
, sync
);
1196 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
, inum
);
1197 release_head(c
, BASEHD
);
1200 sz
= offs
+ UBIFS_INO_NODE_SZ
+ UBIFS_TRUN_NODE_SZ
;
1201 err
= ubifs_tnc_add(c
, &key
, lnum
, sz
, dlen
);
1206 ino_key_init(c
, &key
, inum
);
1207 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, UBIFS_INO_NODE_SZ
);
1211 err
= ubifs_add_dirt(c
, lnum
, UBIFS_TRUN_NODE_SZ
);
1215 bit
= new_size
& (UBIFS_BLOCK_SIZE
- 1);
1216 blk
= (new_size
>> UBIFS_BLOCK_SHIFT
) + (bit
? 1 : 0);
1217 data_key_init(c
, &key
, inum
, blk
);
1219 bit
= old_size
& (UBIFS_BLOCK_SIZE
- 1);
1220 blk
= (old_size
>> UBIFS_BLOCK_SHIFT
) - (bit
? 0: 1);
1221 data_key_init(c
, &to_key
, inum
, blk
);
1223 err
= ubifs_tnc_remove_range(c
, &key
, &to_key
);
1227 finish_reservation(c
);
1228 spin_lock(&ui
->ui_lock
);
1229 ui
->synced_i_size
= ui
->ui_size
;
1230 spin_unlock(&ui
->ui_lock
);
1231 mark_inode_clean(c
, ui
);
1236 release_head(c
, BASEHD
);
1238 ubifs_ro_mode(c
, err
);
1239 finish_reservation(c
);
1245 #ifdef CONFIG_UBIFS_FS_XATTR
1248 * ubifs_jnl_delete_xattr - delete an extended attribute.
1249 * @c: UBIFS file-system description object
1251 * @inode: extended attribute inode
1252 * @nm: extended attribute entry name
1254 * This function delete an extended attribute which is very similar to
1255 * un-linking regular files - it writes a deletion xentry, a deletion inode and
1256 * updates the target inode. Returns zero in case of success and a negative
1257 * error code in case of failure.
1259 int ubifs_jnl_delete_xattr(struct ubifs_info
*c
, const struct inode
*host
,
1260 const struct inode
*inode
, const struct qstr
*nm
)
1262 int err
, xlen
, hlen
, len
, lnum
, xent_offs
, aligned_xlen
;
1263 struct ubifs_dent_node
*xent
;
1264 struct ubifs_ino_node
*ino
;
1265 union ubifs_key xent_key
, key1
, key2
;
1266 int sync
= IS_DIRSYNC(host
);
1267 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
1269 dbg_jnl("host %lu, xattr ino %lu, name '%s', data len %d",
1270 host
->i_ino
, inode
->i_ino
, nm
->name
,
1271 ubifs_inode(inode
)->data_len
);
1272 ubifs_assert(inode
->i_nlink
== 0);
1273 ubifs_assert(mutex_is_locked(&host_ui
->ui_mutex
));
1276 * Since we are deleting the inode, we do not bother to attach any data
1277 * to it and assume its length is %UBIFS_INO_NODE_SZ.
1279 xlen
= UBIFS_DENT_NODE_SZ
+ nm
->len
+ 1;
1280 aligned_xlen
= ALIGN(xlen
, 8);
1281 hlen
= host_ui
->data_len
+ UBIFS_INO_NODE_SZ
;
1282 len
= aligned_xlen
+ UBIFS_INO_NODE_SZ
+ ALIGN(hlen
, 8);
1284 xent
= kmalloc(len
, GFP_NOFS
);
1288 /* Make reservation before allocating sequence numbers */
1289 err
= make_reservation(c
, BASEHD
, len
);
1295 xent
->ch
.node_type
= UBIFS_XENT_NODE
;
1296 xent_key_init(c
, &xent_key
, host
->i_ino
, nm
);
1297 key_write(c
, &xent_key
, xent
->key
);
1299 xent
->type
= get_dent_type(inode
->i_mode
);
1300 xent
->nlen
= cpu_to_le16(nm
->len
);
1301 memcpy(xent
->name
, nm
->name
, nm
->len
);
1302 xent
->name
[nm
->len
] = '\0';
1303 zero_dent_node_unused(xent
);
1304 ubifs_prep_grp_node(c
, xent
, xlen
, 0);
1306 ino
= (void *)xent
+ aligned_xlen
;
1307 pack_inode(c
, ino
, inode
, 0);
1308 ino
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
1309 pack_inode(c
, ino
, host
, 1);
1311 err
= write_head(c
, BASEHD
, xent
, len
, &lnum
, &xent_offs
, sync
);
1313 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
, host
->i_ino
);
1314 release_head(c
, BASEHD
);
1319 /* Remove the extended attribute entry from TNC */
1320 err
= ubifs_tnc_remove_nm(c
, &xent_key
, nm
);
1323 err
= ubifs_add_dirt(c
, lnum
, xlen
);
1328 * Remove all nodes belonging to the extended attribute inode from TNC.
1329 * Well, there actually must be only one node - the inode itself.
1331 lowest_ino_key(c
, &key1
, inode
->i_ino
);
1332 highest_ino_key(c
, &key2
, inode
->i_ino
);
1333 err
= ubifs_tnc_remove_range(c
, &key1
, &key2
);
1336 err
= ubifs_add_dirt(c
, lnum
, UBIFS_INO_NODE_SZ
);
1340 /* And update TNC with the new host inode position */
1341 ino_key_init(c
, &key1
, host
->i_ino
);
1342 err
= ubifs_tnc_add(c
, &key1
, lnum
, xent_offs
+ len
- hlen
, hlen
);
1346 finish_reservation(c
);
1347 spin_lock(&host_ui
->ui_lock
);
1348 host_ui
->synced_i_size
= host_ui
->ui_size
;
1349 spin_unlock(&host_ui
->ui_lock
);
1350 mark_inode_clean(c
, host_ui
);
1354 ubifs_ro_mode(c
, err
);
1355 finish_reservation(c
);
1360 * ubifs_jnl_change_xattr - change an extended attribute.
1361 * @c: UBIFS file-system description object
1362 * @inode: extended attribute inode
1365 * This function writes the updated version of an extended attribute inode and
1366 * the host inode tho the journal (to the base head). The host inode is written
1367 * after the extended attribute inode in order to guarantee that the extended
1368 * attribute will be flushed when the inode is synchronized by 'fsync()' and
1369 * consequently, the write-buffer is synchronized. This function returns zero
1370 * in case of success and a negative error code in case of failure.
1372 int ubifs_jnl_change_xattr(struct ubifs_info
*c
, const struct inode
*inode
,
1373 const struct inode
*host
)
1375 int err
, len1
, len2
, aligned_len
, aligned_len1
, lnum
, offs
;
1376 struct ubifs_inode
*host_ui
= ubifs_inode(inode
);
1377 struct ubifs_ino_node
*ino
;
1378 union ubifs_key key
;
1379 int sync
= IS_DIRSYNC(host
);
1381 dbg_jnl("ino %lu, ino %lu", host
->i_ino
, inode
->i_ino
);
1382 ubifs_assert(host
->i_nlink
> 0);
1383 ubifs_assert(inode
->i_nlink
> 0);
1384 ubifs_assert(mutex_is_locked(&host_ui
->ui_mutex
));
1386 len1
= UBIFS_INO_NODE_SZ
+ host_ui
->data_len
;
1387 len2
= UBIFS_INO_NODE_SZ
+ ubifs_inode(inode
)->data_len
;
1388 aligned_len1
= ALIGN(len1
, 8);
1389 aligned_len
= aligned_len1
+ ALIGN(len2
, 8);
1391 ino
= kmalloc(aligned_len
, GFP_NOFS
);
1395 /* Make reservation before allocating sequence numbers */
1396 err
= make_reservation(c
, BASEHD
, aligned_len
);
1400 pack_inode(c
, ino
, host
, 0);
1401 pack_inode(c
, (void *)ino
+ aligned_len1
, inode
, 1);
1403 err
= write_head(c
, BASEHD
, ino
, aligned_len
, &lnum
, &offs
, 0);
1404 if (!sync
&& !err
) {
1405 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1407 ubifs_wbuf_add_ino_nolock(wbuf
, host
->i_ino
);
1408 ubifs_wbuf_add_ino_nolock(wbuf
, inode
->i_ino
);
1410 release_head(c
, BASEHD
);
1414 ino_key_init(c
, &key
, host
->i_ino
);
1415 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, len1
);
1419 ino_key_init(c
, &key
, inode
->i_ino
);
1420 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
+ aligned_len1
, len2
);
1424 finish_reservation(c
);
1425 spin_lock(&host_ui
->ui_lock
);
1426 host_ui
->synced_i_size
= host_ui
->ui_size
;
1427 spin_unlock(&host_ui
->ui_lock
);
1428 mark_inode_clean(c
, host_ui
);
1433 ubifs_ro_mode(c
, err
);
1434 finish_reservation(c
);
1440 #endif /* CONFIG_UBIFS_FS_XATTR */