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
)
84 * zero_trun_node_unused - zero out unused fields of an on-flash truncation
86 * @trun: the truncation node to zero out
88 static inline void zero_trun_node_unused(struct ubifs_trun_node
*trun
)
90 memset(trun
->padding
, 0, 12);
93 static void ubifs_add_auth_dirt(struct ubifs_info
*c
, int lnum
)
95 if (ubifs_authenticated(c
))
96 ubifs_add_dirt(c
, lnum
, ubifs_auth_node_sz(c
));
100 * reserve_space - reserve space in the journal.
101 * @c: UBIFS file-system description object
102 * @jhead: journal head number
105 * This function reserves space in journal head @head. If the reservation
106 * succeeded, the journal head stays locked and later has to be unlocked using
107 * 'release_head()'. Returns zero in case of success, %-EAGAIN if commit has to
108 * be done, and other negative error codes in case of other failures.
110 static int reserve_space(struct ubifs_info
*c
, int jhead
, int len
)
112 int err
= 0, err1
, retries
= 0, avail
, lnum
, offs
, squeeze
;
113 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
116 * Typically, the base head has smaller nodes written to it, so it is
117 * better to try to allocate space at the ends of eraseblocks. This is
118 * what the squeeze parameter does.
120 ubifs_assert(c
, !c
->ro_media
&& !c
->ro_mount
);
121 squeeze
= (jhead
== BASEHD
);
123 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
130 avail
= c
->leb_size
- wbuf
->offs
- wbuf
->used
;
131 if (wbuf
->lnum
!= -1 && avail
>= len
)
135 * Write buffer wasn't seek'ed or there is no enough space - look for an
136 * LEB with some empty space.
138 lnum
= ubifs_find_free_space(c
, len
, &offs
, squeeze
);
147 * No free space, we have to run garbage collector to make
148 * some. But the write-buffer mutex has to be unlocked because
151 dbg_jnl("no free space in jhead %s, run GC", dbg_jhead(jhead
));
152 mutex_unlock(&wbuf
->io_mutex
);
154 lnum
= ubifs_garbage_collect(c
, 0);
161 * GC could not make a free LEB. But someone else may
162 * have allocated new bud for this journal head,
163 * because we dropped @wbuf->io_mutex, so try once
166 dbg_jnl("GC couldn't make a free LEB for jhead %s",
169 dbg_jnl("retry (%d)", retries
);
173 dbg_jnl("return -ENOSPC");
177 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
178 dbg_jnl("got LEB %d for jhead %s", lnum
, dbg_jhead(jhead
));
179 avail
= c
->leb_size
- wbuf
->offs
- wbuf
->used
;
181 if (wbuf
->lnum
!= -1 && avail
>= len
) {
183 * Someone else has switched the journal head and we have
184 * enough space now. This happens when more than one process is
185 * trying to write to the same journal head at the same time.
187 dbg_jnl("return LEB %d back, already have LEB %d:%d",
188 lnum
, wbuf
->lnum
, wbuf
->offs
+ wbuf
->used
);
189 err
= ubifs_return_leb(c
, lnum
);
199 * Make sure we synchronize the write-buffer before we add the new bud
200 * to the log. Otherwise we may have a power cut after the log
201 * reference node for the last bud (@lnum) is written but before the
202 * write-buffer data are written to the next-to-last bud
203 * (@wbuf->lnum). And the effect would be that the recovery would see
204 * that there is corruption in the next-to-last bud.
206 err
= ubifs_wbuf_sync_nolock(wbuf
);
209 err
= ubifs_add_bud_to_log(c
, jhead
, lnum
, offs
);
212 err
= ubifs_wbuf_seek_nolock(wbuf
, lnum
, offs
);
219 mutex_unlock(&wbuf
->io_mutex
);
223 /* An error occurred and the LEB has to be returned to lprops */
224 ubifs_assert(c
, err
< 0);
225 err1
= ubifs_return_leb(c
, lnum
);
226 if (err1
&& err
== -EAGAIN
)
228 * Return original error code only if it is not %-EAGAIN,
229 * which is not really an error. Otherwise, return the error
230 * code of 'ubifs_return_leb()'.
233 mutex_unlock(&wbuf
->io_mutex
);
237 static int ubifs_hash_nodes(struct ubifs_info
*c
, void *node
,
238 int len
, struct shash_desc
*hash
)
240 int auth_node_size
= ubifs_auth_node_sz(c
);
244 const struct ubifs_ch
*ch
= node
;
245 int nodelen
= le32_to_cpu(ch
->len
);
247 ubifs_assert(c
, len
>= auth_node_size
);
249 if (len
== auth_node_size
)
252 ubifs_assert(c
, len
> nodelen
);
253 ubifs_assert(c
, ch
->magic
== cpu_to_le32(UBIFS_NODE_MAGIC
));
255 err
= ubifs_shash_update(c
, hash
, (void *)node
, nodelen
);
259 node
+= ALIGN(nodelen
, 8);
260 len
-= ALIGN(nodelen
, 8);
263 return ubifs_prepare_auth_node(c
, node
, hash
);
267 * write_head - write data to a journal head.
268 * @c: UBIFS file-system description object
269 * @jhead: journal head
270 * @buf: buffer to write
271 * @len: length to write
272 * @lnum: LEB number written is returned here
273 * @offs: offset written is returned here
274 * @sync: non-zero if the write-buffer has to by synchronized
276 * This function writes data to the reserved space of journal head @jhead.
277 * Returns zero in case of success and a negative error code in case of
280 static int write_head(struct ubifs_info
*c
, int jhead
, void *buf
, int len
,
281 int *lnum
, int *offs
, int sync
)
284 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
286 ubifs_assert(c
, jhead
!= GCHD
);
288 *lnum
= c
->jheads
[jhead
].wbuf
.lnum
;
289 *offs
= c
->jheads
[jhead
].wbuf
.offs
+ c
->jheads
[jhead
].wbuf
.used
;
290 dbg_jnl("jhead %s, LEB %d:%d, len %d",
291 dbg_jhead(jhead
), *lnum
, *offs
, len
);
293 if (ubifs_authenticated(c
)) {
294 err
= ubifs_hash_nodes(c
, buf
, len
, c
->jheads
[jhead
].log_hash
);
299 err
= ubifs_wbuf_write_nolock(wbuf
, buf
, len
);
303 err
= ubifs_wbuf_sync_nolock(wbuf
);
308 * make_reservation - reserve journal space.
309 * @c: UBIFS file-system description object
310 * @jhead: journal head
311 * @len: how many bytes to reserve
313 * This function makes space reservation in journal head @jhead. The function
314 * takes the commit lock and locks the journal head, and the caller has to
315 * unlock the head and finish the reservation with 'finish_reservation()'.
316 * Returns zero in case of success and a negative error code in case of
319 * Note, the journal head may be unlocked as soon as the data is written, while
320 * the commit lock has to be released after the data has been added to the
323 static int make_reservation(struct ubifs_info
*c
, int jhead
, int len
)
325 int err
, cmt_retries
= 0, nospc_retries
= 0;
328 down_read(&c
->commit_sem
);
329 err
= reserve_space(c
, jhead
, len
);
331 /* c->commit_sem will get released via finish_reservation(). */
333 up_read(&c
->commit_sem
);
335 if (err
== -ENOSPC
) {
337 * GC could not make any progress. We should try to commit
338 * once because it could make some dirty space and GC would
339 * make progress, so make the error -EAGAIN so that the below
340 * will commit and re-try.
342 if (nospc_retries
++ < 2) {
343 dbg_jnl("no space, retry");
348 * This means that the budgeting is incorrect. We always have
349 * to be able to write to the media, because all operations are
350 * budgeted. Deletions are not budgeted, though, but we reserve
351 * an extra LEB for them.
359 * -EAGAIN means that the journal is full or too large, or the above
360 * code wants to do one commit. Do this and re-try.
362 if (cmt_retries
> 128) {
364 * This should not happen unless the journal size limitations
367 ubifs_err(c
, "stuck in space allocation");
370 } else if (cmt_retries
> 32)
371 ubifs_warn(c
, "too many space allocation re-tries (%d)",
374 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
378 err
= ubifs_run_commit(c
);
384 ubifs_err(c
, "cannot reserve %d bytes in jhead %d, error %d",
386 if (err
== -ENOSPC
) {
387 /* This are some budgeting problems, print useful information */
388 down_write(&c
->commit_sem
);
390 ubifs_dump_budg(c
, &c
->bi
);
391 ubifs_dump_lprops(c
);
392 cmt_retries
= dbg_check_lprops(c
);
393 up_write(&c
->commit_sem
);
399 * release_head - release a journal head.
400 * @c: UBIFS file-system description object
401 * @jhead: journal head
403 * This function releases journal head @jhead which was locked by
404 * the 'make_reservation()' function. It has to be called after each successful
405 * 'make_reservation()' invocation.
407 static inline void release_head(struct ubifs_info
*c
, int jhead
)
409 mutex_unlock(&c
->jheads
[jhead
].wbuf
.io_mutex
);
413 * finish_reservation - finish a reservation.
414 * @c: UBIFS file-system description object
416 * This function finishes journal space reservation. It must be called after
417 * 'make_reservation()'.
419 static void finish_reservation(struct ubifs_info
*c
)
421 up_read(&c
->commit_sem
);
425 * get_dent_type - translate VFS inode mode to UBIFS directory entry type.
428 static int get_dent_type(int mode
)
430 switch (mode
& S_IFMT
) {
432 return UBIFS_ITYPE_REG
;
434 return UBIFS_ITYPE_DIR
;
436 return UBIFS_ITYPE_LNK
;
438 return UBIFS_ITYPE_BLK
;
440 return UBIFS_ITYPE_CHR
;
442 return UBIFS_ITYPE_FIFO
;
444 return UBIFS_ITYPE_SOCK
;
452 * pack_inode - pack an inode node.
453 * @c: UBIFS file-system description object
454 * @ino: buffer in which to pack inode node
455 * @inode: inode to pack
456 * @last: indicates the last node of the group
458 static void pack_inode(struct ubifs_info
*c
, struct ubifs_ino_node
*ino
,
459 const struct inode
*inode
, int last
)
461 int data_len
= 0, last_reference
= !inode
->i_nlink
;
462 struct ubifs_inode
*ui
= ubifs_inode(inode
);
464 ino
->ch
.node_type
= UBIFS_INO_NODE
;
465 ino_key_init_flash(c
, &ino
->key
, inode
->i_ino
);
466 ino
->creat_sqnum
= cpu_to_le64(ui
->creat_sqnum
);
467 ino
->atime_sec
= cpu_to_le64(inode
->i_atime
.tv_sec
);
468 ino
->atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
469 ino
->ctime_sec
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
470 ino
->ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
471 ino
->mtime_sec
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
472 ino
->mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
473 ino
->uid
= cpu_to_le32(i_uid_read(inode
));
474 ino
->gid
= cpu_to_le32(i_gid_read(inode
));
475 ino
->mode
= cpu_to_le32(inode
->i_mode
);
476 ino
->flags
= cpu_to_le32(ui
->flags
);
477 ino
->size
= cpu_to_le64(ui
->ui_size
);
478 ino
->nlink
= cpu_to_le32(inode
->i_nlink
);
479 ino
->compr_type
= cpu_to_le16(ui
->compr_type
);
480 ino
->data_len
= cpu_to_le32(ui
->data_len
);
481 ino
->xattr_cnt
= cpu_to_le32(ui
->xattr_cnt
);
482 ino
->xattr_size
= cpu_to_le32(ui
->xattr_size
);
483 ino
->xattr_names
= cpu_to_le32(ui
->xattr_names
);
484 zero_ino_node_unused(ino
);
487 * Drop the attached data if this is a deletion inode, the data is not
490 if (!last_reference
) {
491 memcpy(ino
->data
, ui
->data
, ui
->data_len
);
492 data_len
= ui
->data_len
;
495 ubifs_prep_grp_node(c
, ino
, UBIFS_INO_NODE_SZ
+ data_len
, last
);
499 * mark_inode_clean - mark UBIFS inode as clean.
500 * @c: UBIFS file-system description object
501 * @ui: UBIFS inode to mark as clean
503 * This helper function marks UBIFS inode @ui as clean by cleaning the
504 * @ui->dirty flag and releasing its budget. Note, VFS may still treat the
505 * inode as dirty and try to write it back, but 'ubifs_write_inode()' would
508 static void mark_inode_clean(struct ubifs_info
*c
, struct ubifs_inode
*ui
)
511 ubifs_release_dirty_inode_budget(c
, ui
);
515 static void set_dent_cookie(struct ubifs_info
*c
, struct ubifs_dent_node
*dent
)
518 dent
->cookie
= prandom_u32();
524 * ubifs_jnl_update - update inode.
525 * @c: UBIFS file-system description object
526 * @dir: parent inode or host inode in case of extended attributes
527 * @nm: directory entry name
528 * @inode: inode to update
529 * @deletion: indicates a directory entry deletion i.e unlink or rmdir
530 * @xent: non-zero if the directory entry is an extended attribute entry
532 * This function updates an inode by writing a directory entry (or extended
533 * attribute entry), the inode itself, and the parent directory inode (or the
534 * host inode) to the journal.
536 * The function writes the host inode @dir last, which is important in case of
537 * extended attributes. Indeed, then we guarantee that if the host inode gets
538 * synchronized (with 'fsync()'), and the write-buffer it sits in gets flushed,
539 * the extended attribute inode gets flushed too. And this is exactly what the
540 * user expects - synchronizing the host inode synchronizes its extended
541 * attributes. Similarly, this guarantees that if @dir is synchronized, its
542 * directory entry corresponding to @nm gets synchronized too.
544 * If the inode (@inode) or the parent directory (@dir) are synchronous, this
545 * function synchronizes the write-buffer.
547 * This function marks the @dir and @inode inodes as clean and returns zero on
548 * success. In case of failure, a negative error code is returned.
550 int ubifs_jnl_update(struct ubifs_info
*c
, const struct inode
*dir
,
551 const struct fscrypt_name
*nm
, const struct inode
*inode
,
552 int deletion
, int xent
)
554 int err
, dlen
, ilen
, len
, lnum
, ino_offs
, dent_offs
;
555 int aligned_dlen
, aligned_ilen
, sync
= IS_DIRSYNC(dir
);
556 int last_reference
= !!(deletion
&& inode
->i_nlink
== 0);
557 struct ubifs_inode
*ui
= ubifs_inode(inode
);
558 struct ubifs_inode
*host_ui
= ubifs_inode(dir
);
559 struct ubifs_dent_node
*dent
;
560 struct ubifs_ino_node
*ino
;
561 union ubifs_key dent_key
, ino_key
;
562 u8 hash_dent
[UBIFS_HASH_ARR_SZ
];
563 u8 hash_ino
[UBIFS_HASH_ARR_SZ
];
564 u8 hash_ino_host
[UBIFS_HASH_ARR_SZ
];
566 ubifs_assert(c
, mutex_is_locked(&host_ui
->ui_mutex
));
568 dlen
= UBIFS_DENT_NODE_SZ
+ fname_len(nm
) + 1;
569 ilen
= UBIFS_INO_NODE_SZ
;
572 * If the last reference to the inode is being deleted, then there is
573 * no need to attach and write inode data, it is being deleted anyway.
574 * And if the inode is being deleted, no need to synchronize
575 * write-buffer even if the inode is synchronous.
577 if (!last_reference
) {
578 ilen
+= ui
->data_len
;
579 sync
|= IS_SYNC(inode
);
582 aligned_dlen
= ALIGN(dlen
, 8);
583 aligned_ilen
= ALIGN(ilen
, 8);
585 len
= aligned_dlen
+ aligned_ilen
+ UBIFS_INO_NODE_SZ
;
586 /* Make sure to also account for extended attributes */
587 if (ubifs_authenticated(c
))
588 len
+= ALIGN(host_ui
->data_len
, 8) + ubifs_auth_node_sz(c
);
590 len
+= host_ui
->data_len
;
592 dent
= kzalloc(len
, GFP_NOFS
);
596 /* Make reservation before allocating sequence numbers */
597 err
= make_reservation(c
, BASEHD
, len
);
602 dent
->ch
.node_type
= UBIFS_DENT_NODE
;
604 dent_key_init_hash(c
, &dent_key
, dir
->i_ino
, nm
->hash
);
606 dent_key_init(c
, &dent_key
, dir
->i_ino
, nm
);
608 dent
->ch
.node_type
= UBIFS_XENT_NODE
;
609 xent_key_init(c
, &dent_key
, dir
->i_ino
, nm
);
612 key_write(c
, &dent_key
, dent
->key
);
613 dent
->inum
= deletion
? 0 : cpu_to_le64(inode
->i_ino
);
614 dent
->type
= get_dent_type(inode
->i_mode
);
615 dent
->nlen
= cpu_to_le16(fname_len(nm
));
616 memcpy(dent
->name
, fname_name(nm
), fname_len(nm
));
617 dent
->name
[fname_len(nm
)] = '\0';
618 set_dent_cookie(c
, dent
);
620 zero_dent_node_unused(dent
);
621 ubifs_prep_grp_node(c
, dent
, dlen
, 0);
622 err
= ubifs_node_calc_hash(c
, dent
, hash_dent
);
626 ino
= (void *)dent
+ aligned_dlen
;
627 pack_inode(c
, ino
, inode
, 0);
628 err
= ubifs_node_calc_hash(c
, ino
, hash_ino
);
632 ino
= (void *)ino
+ aligned_ilen
;
633 pack_inode(c
, ino
, dir
, 1);
634 err
= ubifs_node_calc_hash(c
, ino
, hash_ino_host
);
638 if (last_reference
) {
639 err
= ubifs_add_orphan(c
, inode
->i_ino
);
641 release_head(c
, BASEHD
);
644 ui
->del_cmtno
= c
->cmt_no
;
647 err
= write_head(c
, BASEHD
, dent
, len
, &lnum
, &dent_offs
, sync
);
651 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
653 ubifs_wbuf_add_ino_nolock(wbuf
, inode
->i_ino
);
654 ubifs_wbuf_add_ino_nolock(wbuf
, dir
->i_ino
);
656 release_head(c
, BASEHD
);
658 ubifs_add_auth_dirt(c
, lnum
);
662 err
= ubifs_tnc_remove_dh(c
, &dent_key
, nm
->minor_hash
);
664 err
= ubifs_tnc_remove_nm(c
, &dent_key
, nm
);
667 err
= ubifs_add_dirt(c
, lnum
, dlen
);
669 err
= ubifs_tnc_add_nm(c
, &dent_key
, lnum
, dent_offs
, dlen
,
675 * Note, we do not remove the inode from TNC even if the last reference
676 * to it has just been deleted, because the inode may still be opened.
677 * Instead, the inode has been added to orphan lists and the orphan
678 * subsystem will take further care about it.
680 ino_key_init(c
, &ino_key
, inode
->i_ino
);
681 ino_offs
= dent_offs
+ aligned_dlen
;
682 err
= ubifs_tnc_add(c
, &ino_key
, lnum
, ino_offs
, ilen
, hash_ino
);
686 ino_key_init(c
, &ino_key
, dir
->i_ino
);
687 ino_offs
+= aligned_ilen
;
688 err
= ubifs_tnc_add(c
, &ino_key
, lnum
, ino_offs
,
689 UBIFS_INO_NODE_SZ
+ host_ui
->data_len
, hash_ino_host
);
693 finish_reservation(c
);
694 spin_lock(&ui
->ui_lock
);
695 ui
->synced_i_size
= ui
->ui_size
;
696 spin_unlock(&ui
->ui_lock
);
698 spin_lock(&host_ui
->ui_lock
);
699 host_ui
->synced_i_size
= host_ui
->ui_size
;
700 spin_unlock(&host_ui
->ui_lock
);
702 mark_inode_clean(c
, ui
);
703 mark_inode_clean(c
, host_ui
);
707 finish_reservation(c
);
713 release_head(c
, BASEHD
);
716 ubifs_ro_mode(c
, err
);
718 ubifs_delete_orphan(c
, inode
->i_ino
);
719 finish_reservation(c
);
724 * ubifs_jnl_write_data - write a data node to the journal.
725 * @c: UBIFS file-system description object
726 * @inode: inode the data node belongs to
728 * @buf: buffer to write
729 * @len: data length (must not exceed %UBIFS_BLOCK_SIZE)
731 * This function writes a data node to the journal. Returns %0 if the data node
732 * was successfully written, and a negative error code in case of failure.
734 int ubifs_jnl_write_data(struct ubifs_info
*c
, const struct inode
*inode
,
735 const union ubifs_key
*key
, const void *buf
, int len
)
737 struct ubifs_data_node
*data
;
738 int err
, lnum
, offs
, compr_type
, out_len
, compr_len
, auth_len
;
739 int dlen
= COMPRESSED_DATA_NODE_BUF_SZ
, allocated
= 1;
741 struct ubifs_inode
*ui
= ubifs_inode(inode
);
742 bool encrypted
= ubifs_crypt_is_encrypted(inode
);
743 u8 hash
[UBIFS_HASH_ARR_SZ
];
745 dbg_jnlk(key
, "ino %lu, blk %u, len %d, key ",
746 (unsigned long)key_inum(c
, key
), key_block(c
, key
), len
);
747 ubifs_assert(c
, len
<= UBIFS_BLOCK_SIZE
);
750 dlen
+= UBIFS_CIPHER_BLOCK_SIZE
;
752 auth_len
= ubifs_auth_node_sz(c
);
754 data
= kmalloc(dlen
+ auth_len
, GFP_NOFS
| __GFP_NOWARN
);
757 * Fall-back to the write reserve buffer. Note, we might be
758 * currently on the memory reclaim path, when the kernel is
759 * trying to free some memory by writing out dirty pages. The
760 * write reserve buffer helps us to guarantee that we are
761 * always able to write the data.
764 mutex_lock(&c
->write_reserve_mutex
);
765 data
= c
->write_reserve_buf
;
768 data
->ch
.node_type
= UBIFS_DATA_NODE
;
769 key_write(c
, key
, &data
->key
);
770 data
->size
= cpu_to_le32(len
);
772 if (!(ui
->flags
& UBIFS_COMPR_FL
))
773 /* Compression is disabled for this inode */
774 compr_type
= UBIFS_COMPR_NONE
;
776 compr_type
= ui
->compr_type
;
778 out_len
= compr_len
= dlen
- UBIFS_DATA_NODE_SZ
;
779 ubifs_compress(c
, buf
, len
, &data
->data
, &compr_len
, &compr_type
);
780 ubifs_assert(c
, compr_len
<= UBIFS_BLOCK_SIZE
);
783 err
= ubifs_encrypt(inode
, data
, compr_len
, &out_len
, key_block(c
, key
));
788 data
->compr_size
= 0;
792 dlen
= UBIFS_DATA_NODE_SZ
+ out_len
;
793 if (ubifs_authenticated(c
))
794 write_len
= ALIGN(dlen
, 8) + auth_len
;
798 data
->compr_type
= cpu_to_le16(compr_type
);
800 /* Make reservation before allocating sequence numbers */
801 err
= make_reservation(c
, DATAHD
, write_len
);
805 ubifs_prepare_node(c
, data
, dlen
, 0);
806 err
= write_head(c
, DATAHD
, data
, write_len
, &lnum
, &offs
, 0);
810 err
= ubifs_node_calc_hash(c
, data
, hash
);
814 ubifs_wbuf_add_ino_nolock(&c
->jheads
[DATAHD
].wbuf
, key_inum(c
, key
));
815 release_head(c
, DATAHD
);
817 ubifs_add_auth_dirt(c
, lnum
);
819 err
= ubifs_tnc_add(c
, key
, lnum
, offs
, dlen
, hash
);
823 finish_reservation(c
);
825 mutex_unlock(&c
->write_reserve_mutex
);
831 release_head(c
, DATAHD
);
833 ubifs_ro_mode(c
, err
);
834 finish_reservation(c
);
837 mutex_unlock(&c
->write_reserve_mutex
);
844 * ubifs_jnl_write_inode - flush inode to the journal.
845 * @c: UBIFS file-system description object
846 * @inode: inode to flush
848 * This function writes inode @inode to the journal. If the inode is
849 * synchronous, it also synchronizes the write-buffer. Returns zero in case of
850 * success and a negative error code in case of failure.
852 int ubifs_jnl_write_inode(struct ubifs_info
*c
, const struct inode
*inode
)
855 struct ubifs_ino_node
*ino
, *ino_start
;
856 struct ubifs_inode
*ui
= ubifs_inode(inode
);
857 int sync
= 0, write_len
= 0, ilen
= UBIFS_INO_NODE_SZ
;
858 int last_reference
= !inode
->i_nlink
;
859 int kill_xattrs
= ui
->xattr_cnt
&& last_reference
;
860 u8 hash
[UBIFS_HASH_ARR_SZ
];
862 dbg_jnl("ino %lu, nlink %u", inode
->i_ino
, inode
->i_nlink
);
865 * If the inode is being deleted, do not write the attached data. No
866 * need to synchronize the write-buffer either.
868 if (!last_reference
) {
869 ilen
+= ui
->data_len
;
870 sync
= IS_SYNC(inode
);
871 } else if (kill_xattrs
) {
872 write_len
+= UBIFS_INO_NODE_SZ
* ui
->xattr_cnt
;
875 if (ubifs_authenticated(c
))
876 write_len
+= ALIGN(ilen
, 8) + ubifs_auth_node_sz(c
);
880 ino_start
= ino
= kmalloc(write_len
, GFP_NOFS
);
884 /* Make reservation before allocating sequence numbers */
885 err
= make_reservation(c
, BASEHD
, write_len
);
891 struct fscrypt_name nm
= {0};
893 struct ubifs_dent_node
*xent
, *pxent
= NULL
;
895 if (ui
->xattr_cnt
>= ubifs_xattr_max_cnt(c
)) {
896 ubifs_err(c
, "Cannot delete inode, it has too much xattrs!");
900 lowest_xent_key(c
, &key
, inode
->i_ino
);
902 xent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
911 fname_name(&nm
) = xent
->name
;
912 fname_len(&nm
) = le16_to_cpu(xent
->nlen
);
914 xino
= ubifs_iget(c
->vfs_sb
, xent
->inum
);
917 ubifs_err(c
, "dead directory entry '%s', error %d",
919 ubifs_ro_mode(c
, err
);
922 ubifs_assert(c
, ubifs_inode(xino
)->xattr
);
925 pack_inode(c
, ino
, xino
, 0);
926 ino
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
931 key_read(c
, &xent
->key
, &key
);
936 pack_inode(c
, ino
, inode
, 1);
937 err
= ubifs_node_calc_hash(c
, ino
, hash
);
941 err
= write_head(c
, BASEHD
, ino_start
, write_len
, &lnum
, &offs
, sync
);
945 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
,
947 release_head(c
, BASEHD
);
949 ubifs_add_auth_dirt(c
, lnum
);
951 if (last_reference
) {
952 err
= ubifs_tnc_remove_ino(c
, inode
->i_ino
);
955 ubifs_delete_orphan(c
, inode
->i_ino
);
956 err
= ubifs_add_dirt(c
, lnum
, write_len
);
960 ino_key_init(c
, &key
, inode
->i_ino
);
961 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, ilen
, hash
);
966 finish_reservation(c
);
967 spin_lock(&ui
->ui_lock
);
968 ui
->synced_i_size
= ui
->ui_size
;
969 spin_unlock(&ui
->ui_lock
);
974 release_head(c
, BASEHD
);
976 ubifs_ro_mode(c
, err
);
977 finish_reservation(c
);
984 * ubifs_jnl_delete_inode - delete an inode.
985 * @c: UBIFS file-system description object
986 * @inode: inode to delete
988 * This function deletes inode @inode which includes removing it from orphans,
989 * deleting it from TNC and, in some cases, writing a deletion inode to the
992 * When regular file inodes are unlinked or a directory inode is removed, the
993 * 'ubifs_jnl_update()' function writes a corresponding deletion inode and
994 * direntry to the media, and adds the inode to orphans. After this, when the
995 * last reference to this inode has been dropped, this function is called. In
996 * general, it has to write one more deletion inode to the media, because if
997 * a commit happened between 'ubifs_jnl_update()' and
998 * 'ubifs_jnl_delete_inode()', the deletion inode is not in the journal
999 * anymore, and in fact it might not be on the flash anymore, because it might
1000 * have been garbage-collected already. And for optimization reasons UBIFS does
1001 * not read the orphan area if it has been unmounted cleanly, so it would have
1002 * no indication in the journal that there is a deleted inode which has to be
1005 * However, if there was no commit between 'ubifs_jnl_update()' and
1006 * 'ubifs_jnl_delete_inode()', then there is no need to write the deletion
1007 * inode to the media for the second time. And this is quite a typical case.
1009 * This function returns zero in case of success and a negative error code in
1012 int ubifs_jnl_delete_inode(struct ubifs_info
*c
, const struct inode
*inode
)
1015 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1017 ubifs_assert(c
, inode
->i_nlink
== 0);
1019 if (ui
->xattr_cnt
|| ui
->del_cmtno
!= c
->cmt_no
)
1020 /* A commit happened for sure or inode hosts xattrs */
1021 return ubifs_jnl_write_inode(c
, inode
);
1023 down_read(&c
->commit_sem
);
1025 * Check commit number again, because the first test has been done
1026 * without @c->commit_sem, so a commit might have happened.
1028 if (ui
->del_cmtno
!= c
->cmt_no
) {
1029 up_read(&c
->commit_sem
);
1030 return ubifs_jnl_write_inode(c
, inode
);
1033 err
= ubifs_tnc_remove_ino(c
, inode
->i_ino
);
1035 ubifs_ro_mode(c
, err
);
1037 ubifs_delete_orphan(c
, inode
->i_ino
);
1038 up_read(&c
->commit_sem
);
1043 * ubifs_jnl_xrename - cross rename two directory entries.
1044 * @c: UBIFS file-system description object
1045 * @fst_dir: parent inode of 1st directory entry to exchange
1046 * @fst_inode: 1st inode to exchange
1047 * @fst_nm: name of 1st inode to exchange
1048 * @snd_dir: parent inode of 2nd directory entry to exchange
1049 * @snd_inode: 2nd inode to exchange
1050 * @snd_nm: name of 2nd inode to exchange
1051 * @sync: non-zero if the write-buffer has to be synchronized
1053 * This function implements the cross rename operation which may involve
1054 * writing 2 inodes and 2 directory entries. It marks the written inodes as clean
1055 * and returns zero on success. In case of failure, a negative error code is
1058 int ubifs_jnl_xrename(struct ubifs_info
*c
, const struct inode
*fst_dir
,
1059 const struct inode
*fst_inode
,
1060 const struct fscrypt_name
*fst_nm
,
1061 const struct inode
*snd_dir
,
1062 const struct inode
*snd_inode
,
1063 const struct fscrypt_name
*snd_nm
, int sync
)
1065 union ubifs_key key
;
1066 struct ubifs_dent_node
*dent1
, *dent2
;
1067 int err
, dlen1
, dlen2
, lnum
, offs
, len
, plen
= UBIFS_INO_NODE_SZ
;
1068 int aligned_dlen1
, aligned_dlen2
;
1069 int twoparents
= (fst_dir
!= snd_dir
);
1071 u8 hash_dent1
[UBIFS_HASH_ARR_SZ
];
1072 u8 hash_dent2
[UBIFS_HASH_ARR_SZ
];
1073 u8 hash_p1
[UBIFS_HASH_ARR_SZ
];
1074 u8 hash_p2
[UBIFS_HASH_ARR_SZ
];
1076 ubifs_assert(c
, ubifs_inode(fst_dir
)->data_len
== 0);
1077 ubifs_assert(c
, ubifs_inode(snd_dir
)->data_len
== 0);
1078 ubifs_assert(c
, mutex_is_locked(&ubifs_inode(fst_dir
)->ui_mutex
));
1079 ubifs_assert(c
, mutex_is_locked(&ubifs_inode(snd_dir
)->ui_mutex
));
1081 dlen1
= UBIFS_DENT_NODE_SZ
+ fname_len(snd_nm
) + 1;
1082 dlen2
= UBIFS_DENT_NODE_SZ
+ fname_len(fst_nm
) + 1;
1083 aligned_dlen1
= ALIGN(dlen1
, 8);
1084 aligned_dlen2
= ALIGN(dlen2
, 8);
1086 len
= aligned_dlen1
+ aligned_dlen2
+ ALIGN(plen
, 8);
1090 len
+= ubifs_auth_node_sz(c
);
1092 dent1
= kzalloc(len
, GFP_NOFS
);
1096 /* Make reservation before allocating sequence numbers */
1097 err
= make_reservation(c
, BASEHD
, len
);
1101 /* Make new dent for 1st entry */
1102 dent1
->ch
.node_type
= UBIFS_DENT_NODE
;
1103 dent_key_init_flash(c
, &dent1
->key
, snd_dir
->i_ino
, snd_nm
);
1104 dent1
->inum
= cpu_to_le64(fst_inode
->i_ino
);
1105 dent1
->type
= get_dent_type(fst_inode
->i_mode
);
1106 dent1
->nlen
= cpu_to_le16(fname_len(snd_nm
));
1107 memcpy(dent1
->name
, fname_name(snd_nm
), fname_len(snd_nm
));
1108 dent1
->name
[fname_len(snd_nm
)] = '\0';
1109 set_dent_cookie(c
, dent1
);
1110 zero_dent_node_unused(dent1
);
1111 ubifs_prep_grp_node(c
, dent1
, dlen1
, 0);
1112 err
= ubifs_node_calc_hash(c
, dent1
, hash_dent1
);
1116 /* Make new dent for 2nd entry */
1117 dent2
= (void *)dent1
+ aligned_dlen1
;
1118 dent2
->ch
.node_type
= UBIFS_DENT_NODE
;
1119 dent_key_init_flash(c
, &dent2
->key
, fst_dir
->i_ino
, fst_nm
);
1120 dent2
->inum
= cpu_to_le64(snd_inode
->i_ino
);
1121 dent2
->type
= get_dent_type(snd_inode
->i_mode
);
1122 dent2
->nlen
= cpu_to_le16(fname_len(fst_nm
));
1123 memcpy(dent2
->name
, fname_name(fst_nm
), fname_len(fst_nm
));
1124 dent2
->name
[fname_len(fst_nm
)] = '\0';
1125 set_dent_cookie(c
, dent2
);
1126 zero_dent_node_unused(dent2
);
1127 ubifs_prep_grp_node(c
, dent2
, dlen2
, 0);
1128 err
= ubifs_node_calc_hash(c
, dent2
, hash_dent2
);
1132 p
= (void *)dent2
+ aligned_dlen2
;
1134 pack_inode(c
, p
, fst_dir
, 1);
1135 err
= ubifs_node_calc_hash(c
, p
, hash_p1
);
1139 pack_inode(c
, p
, fst_dir
, 0);
1140 err
= ubifs_node_calc_hash(c
, p
, hash_p1
);
1143 p
+= ALIGN(plen
, 8);
1144 pack_inode(c
, p
, snd_dir
, 1);
1145 err
= ubifs_node_calc_hash(c
, p
, hash_p2
);
1150 err
= write_head(c
, BASEHD
, dent1
, len
, &lnum
, &offs
, sync
);
1154 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1156 ubifs_wbuf_add_ino_nolock(wbuf
, fst_dir
->i_ino
);
1157 ubifs_wbuf_add_ino_nolock(wbuf
, snd_dir
->i_ino
);
1159 release_head(c
, BASEHD
);
1161 ubifs_add_auth_dirt(c
, lnum
);
1163 dent_key_init(c
, &key
, snd_dir
->i_ino
, snd_nm
);
1164 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen1
, hash_dent1
, snd_nm
);
1168 offs
+= aligned_dlen1
;
1169 dent_key_init(c
, &key
, fst_dir
->i_ino
, fst_nm
);
1170 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen2
, hash_dent2
, fst_nm
);
1174 offs
+= aligned_dlen2
;
1176 ino_key_init(c
, &key
, fst_dir
->i_ino
);
1177 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
, hash_p1
);
1182 offs
+= ALIGN(plen
, 8);
1183 ino_key_init(c
, &key
, snd_dir
->i_ino
);
1184 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
, hash_p2
);
1189 finish_reservation(c
);
1191 mark_inode_clean(c
, ubifs_inode(fst_dir
));
1193 mark_inode_clean(c
, ubifs_inode(snd_dir
));
1198 release_head(c
, BASEHD
);
1200 ubifs_ro_mode(c
, err
);
1201 finish_reservation(c
);
1208 * ubifs_jnl_rename - rename a directory entry.
1209 * @c: UBIFS file-system description object
1210 * @old_dir: parent inode of directory entry to rename
1211 * @old_dentry: directory entry to rename
1212 * @new_dir: parent inode of directory entry to rename
1213 * @new_dentry: new directory entry (or directory entry to replace)
1214 * @sync: non-zero if the write-buffer has to be synchronized
1216 * This function implements the re-name operation which may involve writing up
1217 * to 4 inodes and 2 directory entries. It marks the written inodes as clean
1218 * and returns zero on success. In case of failure, a negative error code is
1221 int ubifs_jnl_rename(struct ubifs_info
*c
, const struct inode
*old_dir
,
1222 const struct inode
*old_inode
,
1223 const struct fscrypt_name
*old_nm
,
1224 const struct inode
*new_dir
,
1225 const struct inode
*new_inode
,
1226 const struct fscrypt_name
*new_nm
,
1227 const struct inode
*whiteout
, int sync
)
1230 union ubifs_key key
;
1231 struct ubifs_dent_node
*dent
, *dent2
;
1232 int err
, dlen1
, dlen2
, ilen
, lnum
, offs
, len
;
1233 int aligned_dlen1
, aligned_dlen2
, plen
= UBIFS_INO_NODE_SZ
;
1234 int last_reference
= !!(new_inode
&& new_inode
->i_nlink
== 0);
1235 int move
= (old_dir
!= new_dir
);
1236 struct ubifs_inode
*uninitialized_var(new_ui
);
1237 u8 hash_old_dir
[UBIFS_HASH_ARR_SZ
];
1238 u8 hash_new_dir
[UBIFS_HASH_ARR_SZ
];
1239 u8 hash_new_inode
[UBIFS_HASH_ARR_SZ
];
1240 u8 hash_dent1
[UBIFS_HASH_ARR_SZ
];
1241 u8 hash_dent2
[UBIFS_HASH_ARR_SZ
];
1243 ubifs_assert(c
, ubifs_inode(old_dir
)->data_len
== 0);
1244 ubifs_assert(c
, ubifs_inode(new_dir
)->data_len
== 0);
1245 ubifs_assert(c
, mutex_is_locked(&ubifs_inode(old_dir
)->ui_mutex
));
1246 ubifs_assert(c
, mutex_is_locked(&ubifs_inode(new_dir
)->ui_mutex
));
1248 dlen1
= UBIFS_DENT_NODE_SZ
+ fname_len(new_nm
) + 1;
1249 dlen2
= UBIFS_DENT_NODE_SZ
+ fname_len(old_nm
) + 1;
1251 new_ui
= ubifs_inode(new_inode
);
1252 ubifs_assert(c
, mutex_is_locked(&new_ui
->ui_mutex
));
1253 ilen
= UBIFS_INO_NODE_SZ
;
1254 if (!last_reference
)
1255 ilen
+= new_ui
->data_len
;
1259 aligned_dlen1
= ALIGN(dlen1
, 8);
1260 aligned_dlen2
= ALIGN(dlen2
, 8);
1261 len
= aligned_dlen1
+ aligned_dlen2
+ ALIGN(ilen
, 8) + ALIGN(plen
, 8);
1265 len
+= ubifs_auth_node_sz(c
);
1267 dent
= kzalloc(len
, GFP_NOFS
);
1271 /* Make reservation before allocating sequence numbers */
1272 err
= make_reservation(c
, BASEHD
, len
);
1277 dent
->ch
.node_type
= UBIFS_DENT_NODE
;
1278 dent_key_init_flash(c
, &dent
->key
, new_dir
->i_ino
, new_nm
);
1279 dent
->inum
= cpu_to_le64(old_inode
->i_ino
);
1280 dent
->type
= get_dent_type(old_inode
->i_mode
);
1281 dent
->nlen
= cpu_to_le16(fname_len(new_nm
));
1282 memcpy(dent
->name
, fname_name(new_nm
), fname_len(new_nm
));
1283 dent
->name
[fname_len(new_nm
)] = '\0';
1284 set_dent_cookie(c
, dent
);
1285 zero_dent_node_unused(dent
);
1286 ubifs_prep_grp_node(c
, dent
, dlen1
, 0);
1287 err
= ubifs_node_calc_hash(c
, dent
, hash_dent1
);
1291 dent2
= (void *)dent
+ aligned_dlen1
;
1292 dent2
->ch
.node_type
= UBIFS_DENT_NODE
;
1293 dent_key_init_flash(c
, &dent2
->key
, old_dir
->i_ino
, old_nm
);
1296 dent2
->inum
= cpu_to_le64(whiteout
->i_ino
);
1297 dent2
->type
= get_dent_type(whiteout
->i_mode
);
1299 /* Make deletion dent */
1301 dent2
->type
= DT_UNKNOWN
;
1303 dent2
->nlen
= cpu_to_le16(fname_len(old_nm
));
1304 memcpy(dent2
->name
, fname_name(old_nm
), fname_len(old_nm
));
1305 dent2
->name
[fname_len(old_nm
)] = '\0';
1306 set_dent_cookie(c
, dent2
);
1307 zero_dent_node_unused(dent2
);
1308 ubifs_prep_grp_node(c
, dent2
, dlen2
, 0);
1309 err
= ubifs_node_calc_hash(c
, dent2
, hash_dent2
);
1313 p
= (void *)dent2
+ aligned_dlen2
;
1315 pack_inode(c
, p
, new_inode
, 0);
1316 err
= ubifs_node_calc_hash(c
, p
, hash_new_inode
);
1320 p
+= ALIGN(ilen
, 8);
1324 pack_inode(c
, p
, old_dir
, 1);
1325 err
= ubifs_node_calc_hash(c
, p
, hash_old_dir
);
1329 pack_inode(c
, p
, old_dir
, 0);
1330 err
= ubifs_node_calc_hash(c
, p
, hash_old_dir
);
1334 p
+= ALIGN(plen
, 8);
1335 pack_inode(c
, p
, new_dir
, 1);
1336 err
= ubifs_node_calc_hash(c
, p
, hash_new_dir
);
1341 if (last_reference
) {
1342 err
= ubifs_add_orphan(c
, new_inode
->i_ino
);
1344 release_head(c
, BASEHD
);
1347 new_ui
->del_cmtno
= c
->cmt_no
;
1350 err
= write_head(c
, BASEHD
, dent
, len
, &lnum
, &offs
, sync
);
1354 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1356 ubifs_wbuf_add_ino_nolock(wbuf
, new_dir
->i_ino
);
1357 ubifs_wbuf_add_ino_nolock(wbuf
, old_dir
->i_ino
);
1359 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
,
1362 release_head(c
, BASEHD
);
1364 ubifs_add_auth_dirt(c
, lnum
);
1366 dent_key_init(c
, &key
, new_dir
->i_ino
, new_nm
);
1367 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen1
, hash_dent1
, new_nm
);
1371 offs
+= aligned_dlen1
;
1373 dent_key_init(c
, &key
, old_dir
->i_ino
, old_nm
);
1374 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen2
, hash_dent2
, old_nm
);
1378 ubifs_delete_orphan(c
, whiteout
->i_ino
);
1380 err
= ubifs_add_dirt(c
, lnum
, dlen2
);
1384 dent_key_init(c
, &key
, old_dir
->i_ino
, old_nm
);
1385 err
= ubifs_tnc_remove_nm(c
, &key
, old_nm
);
1390 offs
+= aligned_dlen2
;
1392 ino_key_init(c
, &key
, new_inode
->i_ino
);
1393 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, ilen
, hash_new_inode
);
1396 offs
+= ALIGN(ilen
, 8);
1399 ino_key_init(c
, &key
, old_dir
->i_ino
);
1400 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
, hash_old_dir
);
1405 offs
+= ALIGN(plen
, 8);
1406 ino_key_init(c
, &key
, new_dir
->i_ino
);
1407 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
, hash_new_dir
);
1412 finish_reservation(c
);
1414 mark_inode_clean(c
, new_ui
);
1415 spin_lock(&new_ui
->ui_lock
);
1416 new_ui
->synced_i_size
= new_ui
->ui_size
;
1417 spin_unlock(&new_ui
->ui_lock
);
1419 mark_inode_clean(c
, ubifs_inode(old_dir
));
1421 mark_inode_clean(c
, ubifs_inode(new_dir
));
1426 release_head(c
, BASEHD
);
1428 ubifs_ro_mode(c
, err
);
1430 ubifs_delete_orphan(c
, new_inode
->i_ino
);
1432 finish_reservation(c
);
1439 * truncate_data_node - re-compress/encrypt a truncated data node.
1440 * @c: UBIFS file-system description object
1441 * @inode: inode which referes to the data node
1442 * @block: data block number
1443 * @dn: data node to re-compress
1444 * @new_len: new length
1446 * This function is used when an inode is truncated and the last data node of
1447 * the inode has to be re-compressed/encrypted and re-written.
1449 static int truncate_data_node(const struct ubifs_info
*c
, const struct inode
*inode
,
1450 unsigned int block
, struct ubifs_data_node
*dn
,
1454 int err
, dlen
, compr_type
, out_len
, old_dlen
;
1456 out_len
= le32_to_cpu(dn
->size
);
1457 buf
= kmalloc_array(out_len
, WORST_COMPR_FACTOR
, GFP_NOFS
);
1461 dlen
= old_dlen
= le32_to_cpu(dn
->ch
.len
) - UBIFS_DATA_NODE_SZ
;
1462 compr_type
= le16_to_cpu(dn
->compr_type
);
1464 if (ubifs_crypt_is_encrypted(inode
)) {
1465 err
= ubifs_decrypt(inode
, dn
, &dlen
, block
);
1470 if (compr_type
== UBIFS_COMPR_NONE
) {
1473 err
= ubifs_decompress(c
, &dn
->data
, dlen
, buf
, &out_len
, compr_type
);
1477 ubifs_compress(c
, buf
, *new_len
, &dn
->data
, &out_len
, &compr_type
);
1480 if (ubifs_crypt_is_encrypted(inode
)) {
1481 err
= ubifs_encrypt(inode
, dn
, out_len
, &old_dlen
, block
);
1490 ubifs_assert(c
, out_len
<= UBIFS_BLOCK_SIZE
);
1491 dn
->compr_type
= cpu_to_le16(compr_type
);
1492 dn
->size
= cpu_to_le32(*new_len
);
1493 *new_len
= UBIFS_DATA_NODE_SZ
+ out_len
;
1501 * ubifs_jnl_truncate - update the journal for a truncation.
1502 * @c: UBIFS file-system description object
1503 * @inode: inode to truncate
1504 * @old_size: old size
1505 * @new_size: new size
1507 * When the size of a file decreases due to truncation, a truncation node is
1508 * written, the journal tree is updated, and the last data block is re-written
1509 * if it has been affected. The inode is also updated in order to synchronize
1510 * the new inode size.
1512 * This function marks the inode as clean and returns zero on success. In case
1513 * of failure, a negative error code is returned.
1515 int ubifs_jnl_truncate(struct ubifs_info
*c
, const struct inode
*inode
,
1516 loff_t old_size
, loff_t new_size
)
1518 union ubifs_key key
, to_key
;
1519 struct ubifs_ino_node
*ino
;
1520 struct ubifs_trun_node
*trun
;
1521 struct ubifs_data_node
*uninitialized_var(dn
);
1522 int err
, dlen
, len
, lnum
, offs
, bit
, sz
, sync
= IS_SYNC(inode
);
1523 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1524 ino_t inum
= inode
->i_ino
;
1526 u8 hash_ino
[UBIFS_HASH_ARR_SZ
];
1527 u8 hash_dn
[UBIFS_HASH_ARR_SZ
];
1529 dbg_jnl("ino %lu, size %lld -> %lld",
1530 (unsigned long)inum
, old_size
, new_size
);
1531 ubifs_assert(c
, !ui
->data_len
);
1532 ubifs_assert(c
, S_ISREG(inode
->i_mode
));
1533 ubifs_assert(c
, mutex_is_locked(&ui
->ui_mutex
));
1535 sz
= UBIFS_TRUN_NODE_SZ
+ UBIFS_INO_NODE_SZ
+
1536 UBIFS_MAX_DATA_NODE_SZ
* WORST_COMPR_FACTOR
;
1538 sz
+= ubifs_auth_node_sz(c
);
1540 ino
= kmalloc(sz
, GFP_NOFS
);
1544 trun
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
1545 trun
->ch
.node_type
= UBIFS_TRUN_NODE
;
1546 trun
->inum
= cpu_to_le32(inum
);
1547 trun
->old_size
= cpu_to_le64(old_size
);
1548 trun
->new_size
= cpu_to_le64(new_size
);
1549 zero_trun_node_unused(trun
);
1551 dlen
= new_size
& (UBIFS_BLOCK_SIZE
- 1);
1553 /* Get last data block so it can be truncated */
1554 dn
= (void *)trun
+ UBIFS_TRUN_NODE_SZ
;
1555 blk
= new_size
>> UBIFS_BLOCK_SHIFT
;
1556 data_key_init(c
, &key
, inum
, blk
);
1557 dbg_jnlk(&key
, "last block key ");
1558 err
= ubifs_tnc_lookup(c
, &key
, dn
);
1560 dlen
= 0; /* Not found (so it is a hole) */
1564 int dn_len
= le32_to_cpu(dn
->size
);
1566 if (dn_len
<= 0 || dn_len
> UBIFS_BLOCK_SIZE
) {
1567 ubifs_err(c
, "bad data node (block %u, inode %lu)",
1569 ubifs_dump_node(c
, dn
);
1574 dlen
= 0; /* Nothing to do */
1576 err
= truncate_data_node(c
, inode
, blk
, dn
, &dlen
);
1583 /* Must make reservation before allocating sequence numbers */
1584 len
= UBIFS_TRUN_NODE_SZ
+ UBIFS_INO_NODE_SZ
;
1586 if (ubifs_authenticated(c
))
1587 len
+= ALIGN(dlen
, 8) + ubifs_auth_node_sz(c
);
1591 err
= make_reservation(c
, BASEHD
, len
);
1595 pack_inode(c
, ino
, inode
, 0);
1596 err
= ubifs_node_calc_hash(c
, ino
, hash_ino
);
1600 ubifs_prep_grp_node(c
, trun
, UBIFS_TRUN_NODE_SZ
, dlen
? 0 : 1);
1602 ubifs_prep_grp_node(c
, dn
, dlen
, 1);
1603 err
= ubifs_node_calc_hash(c
, dn
, hash_dn
);
1608 err
= write_head(c
, BASEHD
, ino
, len
, &lnum
, &offs
, sync
);
1612 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
, inum
);
1613 release_head(c
, BASEHD
);
1615 ubifs_add_auth_dirt(c
, lnum
);
1618 sz
= offs
+ UBIFS_INO_NODE_SZ
+ UBIFS_TRUN_NODE_SZ
;
1619 err
= ubifs_tnc_add(c
, &key
, lnum
, sz
, dlen
, hash_dn
);
1624 ino_key_init(c
, &key
, inum
);
1625 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, UBIFS_INO_NODE_SZ
, hash_ino
);
1629 err
= ubifs_add_dirt(c
, lnum
, UBIFS_TRUN_NODE_SZ
);
1633 bit
= new_size
& (UBIFS_BLOCK_SIZE
- 1);
1634 blk
= (new_size
>> UBIFS_BLOCK_SHIFT
) + (bit
? 1 : 0);
1635 data_key_init(c
, &key
, inum
, blk
);
1637 bit
= old_size
& (UBIFS_BLOCK_SIZE
- 1);
1638 blk
= (old_size
>> UBIFS_BLOCK_SHIFT
) - (bit
? 0 : 1);
1639 data_key_init(c
, &to_key
, inum
, blk
);
1641 err
= ubifs_tnc_remove_range(c
, &key
, &to_key
);
1645 finish_reservation(c
);
1646 spin_lock(&ui
->ui_lock
);
1647 ui
->synced_i_size
= ui
->ui_size
;
1648 spin_unlock(&ui
->ui_lock
);
1649 mark_inode_clean(c
, ui
);
1654 release_head(c
, BASEHD
);
1656 ubifs_ro_mode(c
, err
);
1657 finish_reservation(c
);
1665 * ubifs_jnl_delete_xattr - delete an extended attribute.
1666 * @c: UBIFS file-system description object
1668 * @inode: extended attribute inode
1669 * @nm: extended attribute entry name
1671 * This function delete an extended attribute which is very similar to
1672 * un-linking regular files - it writes a deletion xentry, a deletion inode and
1673 * updates the target inode. Returns zero in case of success and a negative
1674 * error code in case of failure.
1676 int ubifs_jnl_delete_xattr(struct ubifs_info
*c
, const struct inode
*host
,
1677 const struct inode
*inode
,
1678 const struct fscrypt_name
*nm
)
1680 int err
, xlen
, hlen
, len
, lnum
, xent_offs
, aligned_xlen
, write_len
;
1681 struct ubifs_dent_node
*xent
;
1682 struct ubifs_ino_node
*ino
;
1683 union ubifs_key xent_key
, key1
, key2
;
1684 int sync
= IS_DIRSYNC(host
);
1685 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
1686 u8 hash
[UBIFS_HASH_ARR_SZ
];
1688 ubifs_assert(c
, inode
->i_nlink
== 0);
1689 ubifs_assert(c
, mutex_is_locked(&host_ui
->ui_mutex
));
1692 * Since we are deleting the inode, we do not bother to attach any data
1693 * to it and assume its length is %UBIFS_INO_NODE_SZ.
1695 xlen
= UBIFS_DENT_NODE_SZ
+ fname_len(nm
) + 1;
1696 aligned_xlen
= ALIGN(xlen
, 8);
1697 hlen
= host_ui
->data_len
+ UBIFS_INO_NODE_SZ
;
1698 len
= aligned_xlen
+ UBIFS_INO_NODE_SZ
+ ALIGN(hlen
, 8);
1700 write_len
= len
+ ubifs_auth_node_sz(c
);
1702 xent
= kzalloc(write_len
, GFP_NOFS
);
1706 /* Make reservation before allocating sequence numbers */
1707 err
= make_reservation(c
, BASEHD
, write_len
);
1713 xent
->ch
.node_type
= UBIFS_XENT_NODE
;
1714 xent_key_init(c
, &xent_key
, host
->i_ino
, nm
);
1715 key_write(c
, &xent_key
, xent
->key
);
1717 xent
->type
= get_dent_type(inode
->i_mode
);
1718 xent
->nlen
= cpu_to_le16(fname_len(nm
));
1719 memcpy(xent
->name
, fname_name(nm
), fname_len(nm
));
1720 xent
->name
[fname_len(nm
)] = '\0';
1721 zero_dent_node_unused(xent
);
1722 ubifs_prep_grp_node(c
, xent
, xlen
, 0);
1724 ino
= (void *)xent
+ aligned_xlen
;
1725 pack_inode(c
, ino
, inode
, 0);
1726 ino
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
1727 pack_inode(c
, ino
, host
, 1);
1728 err
= ubifs_node_calc_hash(c
, ino
, hash
);
1732 err
= write_head(c
, BASEHD
, xent
, write_len
, &lnum
, &xent_offs
, sync
);
1734 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
, host
->i_ino
);
1735 release_head(c
, BASEHD
);
1737 ubifs_add_auth_dirt(c
, lnum
);
1742 /* Remove the extended attribute entry from TNC */
1743 err
= ubifs_tnc_remove_nm(c
, &xent_key
, nm
);
1746 err
= ubifs_add_dirt(c
, lnum
, xlen
);
1751 * Remove all nodes belonging to the extended attribute inode from TNC.
1752 * Well, there actually must be only one node - the inode itself.
1754 lowest_ino_key(c
, &key1
, inode
->i_ino
);
1755 highest_ino_key(c
, &key2
, inode
->i_ino
);
1756 err
= ubifs_tnc_remove_range(c
, &key1
, &key2
);
1759 err
= ubifs_add_dirt(c
, lnum
, UBIFS_INO_NODE_SZ
);
1763 /* And update TNC with the new host inode position */
1764 ino_key_init(c
, &key1
, host
->i_ino
);
1765 err
= ubifs_tnc_add(c
, &key1
, lnum
, xent_offs
+ len
- hlen
, hlen
, hash
);
1769 finish_reservation(c
);
1770 spin_lock(&host_ui
->ui_lock
);
1771 host_ui
->synced_i_size
= host_ui
->ui_size
;
1772 spin_unlock(&host_ui
->ui_lock
);
1773 mark_inode_clean(c
, host_ui
);
1778 release_head(c
, BASEHD
);
1780 ubifs_ro_mode(c
, err
);
1781 finish_reservation(c
);
1786 * ubifs_jnl_change_xattr - change an extended attribute.
1787 * @c: UBIFS file-system description object
1788 * @inode: extended attribute inode
1791 * This function writes the updated version of an extended attribute inode and
1792 * the host inode to the journal (to the base head). The host inode is written
1793 * after the extended attribute inode in order to guarantee that the extended
1794 * attribute will be flushed when the inode is synchronized by 'fsync()' and
1795 * consequently, the write-buffer is synchronized. This function returns zero
1796 * in case of success and a negative error code in case of failure.
1798 int ubifs_jnl_change_xattr(struct ubifs_info
*c
, const struct inode
*inode
,
1799 const struct inode
*host
)
1801 int err
, len1
, len2
, aligned_len
, aligned_len1
, lnum
, offs
;
1802 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
1803 struct ubifs_ino_node
*ino
;
1804 union ubifs_key key
;
1805 int sync
= IS_DIRSYNC(host
);
1806 u8 hash_host
[UBIFS_HASH_ARR_SZ
];
1807 u8 hash
[UBIFS_HASH_ARR_SZ
];
1809 dbg_jnl("ino %lu, ino %lu", host
->i_ino
, inode
->i_ino
);
1810 ubifs_assert(c
, host
->i_nlink
> 0);
1811 ubifs_assert(c
, inode
->i_nlink
> 0);
1812 ubifs_assert(c
, mutex_is_locked(&host_ui
->ui_mutex
));
1814 len1
= UBIFS_INO_NODE_SZ
+ host_ui
->data_len
;
1815 len2
= UBIFS_INO_NODE_SZ
+ ubifs_inode(inode
)->data_len
;
1816 aligned_len1
= ALIGN(len1
, 8);
1817 aligned_len
= aligned_len1
+ ALIGN(len2
, 8);
1819 aligned_len
+= ubifs_auth_node_sz(c
);
1821 ino
= kzalloc(aligned_len
, GFP_NOFS
);
1825 /* Make reservation before allocating sequence numbers */
1826 err
= make_reservation(c
, BASEHD
, aligned_len
);
1830 pack_inode(c
, ino
, host
, 0);
1831 err
= ubifs_node_calc_hash(c
, ino
, hash_host
);
1834 pack_inode(c
, (void *)ino
+ aligned_len1
, inode
, 1);
1835 err
= ubifs_node_calc_hash(c
, (void *)ino
+ aligned_len1
, hash
);
1839 err
= write_head(c
, BASEHD
, ino
, aligned_len
, &lnum
, &offs
, 0);
1840 if (!sync
&& !err
) {
1841 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1843 ubifs_wbuf_add_ino_nolock(wbuf
, host
->i_ino
);
1844 ubifs_wbuf_add_ino_nolock(wbuf
, inode
->i_ino
);
1846 release_head(c
, BASEHD
);
1850 ubifs_add_auth_dirt(c
, lnum
);
1852 ino_key_init(c
, &key
, host
->i_ino
);
1853 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, len1
, hash_host
);
1857 ino_key_init(c
, &key
, inode
->i_ino
);
1858 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
+ aligned_len1
, len2
, hash
);
1862 finish_reservation(c
);
1863 spin_lock(&host_ui
->ui_lock
);
1864 host_ui
->synced_i_size
= host_ui
->ui_size
;
1865 spin_unlock(&host_ui
->ui_lock
);
1866 mark_inode_clean(c
, host_ui
);
1871 release_head(c
, BASEHD
);
1873 ubifs_ro_mode(c
, err
);
1874 finish_reservation(c
);