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);
94 * reserve_space - reserve space in the journal.
95 * @c: UBIFS file-system description object
96 * @jhead: journal head number
99 * This function reserves space in journal head @head. If the reservation
100 * succeeded, the journal head stays locked and later has to be unlocked using
101 * 'release_head()'. 'write_node()' and 'write_head()' functions also unlock
102 * it. Returns zero in case of success, %-EAGAIN if commit has to be done, and
103 * other negative error codes in case of other failures.
105 static int reserve_space(struct ubifs_info
*c
, int jhead
, int len
)
107 int err
= 0, err1
, retries
= 0, avail
, lnum
, offs
, squeeze
;
108 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
111 * Typically, the base head has smaller nodes written to it, so it is
112 * better to try to allocate space at the ends of eraseblocks. This is
113 * what the squeeze parameter does.
115 ubifs_assert(!c
->ro_media
&& !c
->ro_mount
);
116 squeeze
= (jhead
== BASEHD
);
118 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
125 avail
= c
->leb_size
- wbuf
->offs
- wbuf
->used
;
126 if (wbuf
->lnum
!= -1 && avail
>= len
)
130 * Write buffer wasn't seek'ed or there is no enough space - look for an
131 * LEB with some empty space.
133 lnum
= ubifs_find_free_space(c
, len
, &offs
, squeeze
);
142 * No free space, we have to run garbage collector to make
143 * some. But the write-buffer mutex has to be unlocked because
146 dbg_jnl("no free space in jhead %s, run GC", dbg_jhead(jhead
));
147 mutex_unlock(&wbuf
->io_mutex
);
149 lnum
= ubifs_garbage_collect(c
, 0);
156 * GC could not make a free LEB. But someone else may
157 * have allocated new bud for this journal head,
158 * because we dropped @wbuf->io_mutex, so try once
161 dbg_jnl("GC couldn't make a free LEB for jhead %s",
164 dbg_jnl("retry (%d)", retries
);
168 dbg_jnl("return -ENOSPC");
172 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
173 dbg_jnl("got LEB %d for jhead %s", lnum
, dbg_jhead(jhead
));
174 avail
= c
->leb_size
- wbuf
->offs
- wbuf
->used
;
176 if (wbuf
->lnum
!= -1 && avail
>= len
) {
178 * Someone else has switched the journal head and we have
179 * enough space now. This happens when more than one process is
180 * trying to write to the same journal head at the same time.
182 dbg_jnl("return LEB %d back, already have LEB %d:%d",
183 lnum
, wbuf
->lnum
, wbuf
->offs
+ wbuf
->used
);
184 err
= ubifs_return_leb(c
, lnum
);
194 * Make sure we synchronize the write-buffer before we add the new bud
195 * to the log. Otherwise we may have a power cut after the log
196 * reference node for the last bud (@lnum) is written but before the
197 * write-buffer data are written to the next-to-last bud
198 * (@wbuf->lnum). And the effect would be that the recovery would see
199 * that there is corruption in the next-to-last bud.
201 err
= ubifs_wbuf_sync_nolock(wbuf
);
204 err
= ubifs_add_bud_to_log(c
, jhead
, lnum
, offs
);
207 err
= ubifs_wbuf_seek_nolock(wbuf
, lnum
, offs
);
214 mutex_unlock(&wbuf
->io_mutex
);
218 /* An error occurred and the LEB has to be returned to lprops */
219 ubifs_assert(err
< 0);
220 err1
= ubifs_return_leb(c
, lnum
);
221 if (err1
&& err
== -EAGAIN
)
223 * Return original error code only if it is not %-EAGAIN,
224 * which is not really an error. Otherwise, return the error
225 * code of 'ubifs_return_leb()'.
228 mutex_unlock(&wbuf
->io_mutex
);
233 * write_node - write node to a journal head.
234 * @c: UBIFS file-system description object
235 * @jhead: journal head
236 * @node: node to write
238 * @lnum: LEB number written is returned here
239 * @offs: offset written is returned here
241 * This function writes a node to reserved space of journal head @jhead.
242 * Returns zero in case of success and a negative error code in case of
245 static int write_node(struct ubifs_info
*c
, int jhead
, void *node
, int len
,
246 int *lnum
, int *offs
)
248 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
250 ubifs_assert(jhead
!= GCHD
);
252 *lnum
= c
->jheads
[jhead
].wbuf
.lnum
;
253 *offs
= c
->jheads
[jhead
].wbuf
.offs
+ c
->jheads
[jhead
].wbuf
.used
;
255 dbg_jnl("jhead %s, LEB %d:%d, len %d",
256 dbg_jhead(jhead
), *lnum
, *offs
, len
);
257 ubifs_prepare_node(c
, node
, len
, 0);
259 return ubifs_wbuf_write_nolock(wbuf
, node
, len
);
263 * write_head - write data to a journal head.
264 * @c: UBIFS file-system description object
265 * @jhead: journal head
266 * @buf: buffer to write
267 * @len: length to write
268 * @lnum: LEB number written is returned here
269 * @offs: offset written is returned here
270 * @sync: non-zero if the write-buffer has to by synchronized
272 * This function is the same as 'write_node()' but it does not assume the
273 * buffer it is writing is a node, so it does not prepare it (which means
274 * initializing common header and calculating CRC).
276 static int write_head(struct ubifs_info
*c
, int jhead
, void *buf
, int len
,
277 int *lnum
, int *offs
, int sync
)
280 struct ubifs_wbuf
*wbuf
= &c
->jheads
[jhead
].wbuf
;
282 ubifs_assert(jhead
!= GCHD
);
284 *lnum
= c
->jheads
[jhead
].wbuf
.lnum
;
285 *offs
= c
->jheads
[jhead
].wbuf
.offs
+ c
->jheads
[jhead
].wbuf
.used
;
286 dbg_jnl("jhead %s, LEB %d:%d, len %d",
287 dbg_jhead(jhead
), *lnum
, *offs
, len
);
289 err
= ubifs_wbuf_write_nolock(wbuf
, buf
, len
);
293 err
= ubifs_wbuf_sync_nolock(wbuf
);
298 * make_reservation - reserve journal space.
299 * @c: UBIFS file-system description object
300 * @jhead: journal head
301 * @len: how many bytes to reserve
303 * This function makes space reservation in journal head @jhead. The function
304 * takes the commit lock and locks the journal head, and the caller has to
305 * unlock the head and finish the reservation with 'finish_reservation()'.
306 * Returns zero in case of success and a negative error code in case of
309 * Note, the journal head may be unlocked as soon as the data is written, while
310 * the commit lock has to be released after the data has been added to the
313 static int make_reservation(struct ubifs_info
*c
, int jhead
, int len
)
315 int err
, cmt_retries
= 0, nospc_retries
= 0;
318 down_read(&c
->commit_sem
);
319 err
= reserve_space(c
, jhead
, len
);
322 up_read(&c
->commit_sem
);
324 if (err
== -ENOSPC
) {
326 * GC could not make any progress. We should try to commit
327 * once because it could make some dirty space and GC would
328 * make progress, so make the error -EAGAIN so that the below
329 * will commit and re-try.
331 if (nospc_retries
++ < 2) {
332 dbg_jnl("no space, retry");
337 * This means that the budgeting is incorrect. We always have
338 * to be able to write to the media, because all operations are
339 * budgeted. Deletions are not budgeted, though, but we reserve
340 * an extra LEB for them.
348 * -EAGAIN means that the journal is full or too large, or the above
349 * code wants to do one commit. Do this and re-try.
351 if (cmt_retries
> 128) {
353 * This should not happen unless the journal size limitations
356 ubifs_err(c
, "stuck in space allocation");
359 } else if (cmt_retries
> 32)
360 ubifs_warn(c
, "too many space allocation re-tries (%d)",
363 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
367 err
= ubifs_run_commit(c
);
373 ubifs_err(c
, "cannot reserve %d bytes in jhead %d, error %d",
375 if (err
== -ENOSPC
) {
376 /* This are some budgeting problems, print useful information */
377 down_write(&c
->commit_sem
);
379 ubifs_dump_budg(c
, &c
->bi
);
380 ubifs_dump_lprops(c
);
381 cmt_retries
= dbg_check_lprops(c
);
382 up_write(&c
->commit_sem
);
388 * release_head - release a journal head.
389 * @c: UBIFS file-system description object
390 * @jhead: journal head
392 * This function releases journal head @jhead which was locked by
393 * the 'make_reservation()' function. It has to be called after each successful
394 * 'make_reservation()' invocation.
396 static inline void release_head(struct ubifs_info
*c
, int jhead
)
398 mutex_unlock(&c
->jheads
[jhead
].wbuf
.io_mutex
);
402 * finish_reservation - finish a reservation.
403 * @c: UBIFS file-system description object
405 * This function finishes journal space reservation. It must be called after
406 * 'make_reservation()'.
408 static void finish_reservation(struct ubifs_info
*c
)
410 up_read(&c
->commit_sem
);
414 * get_dent_type - translate VFS inode mode to UBIFS directory entry type.
417 static int get_dent_type(int mode
)
419 switch (mode
& S_IFMT
) {
421 return UBIFS_ITYPE_REG
;
423 return UBIFS_ITYPE_DIR
;
425 return UBIFS_ITYPE_LNK
;
427 return UBIFS_ITYPE_BLK
;
429 return UBIFS_ITYPE_CHR
;
431 return UBIFS_ITYPE_FIFO
;
433 return UBIFS_ITYPE_SOCK
;
441 * pack_inode - pack an inode node.
442 * @c: UBIFS file-system description object
443 * @ino: buffer in which to pack inode node
444 * @inode: inode to pack
445 * @last: indicates the last node of the group
447 static void pack_inode(struct ubifs_info
*c
, struct ubifs_ino_node
*ino
,
448 const struct inode
*inode
, int last
)
450 int data_len
= 0, last_reference
= !inode
->i_nlink
;
451 struct ubifs_inode
*ui
= ubifs_inode(inode
);
453 ino
->ch
.node_type
= UBIFS_INO_NODE
;
454 ino_key_init_flash(c
, &ino
->key
, inode
->i_ino
);
455 ino
->creat_sqnum
= cpu_to_le64(ui
->creat_sqnum
);
456 ino
->atime_sec
= cpu_to_le64(inode
->i_atime
.tv_sec
);
457 ino
->atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
458 ino
->ctime_sec
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
459 ino
->ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
460 ino
->mtime_sec
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
461 ino
->mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
462 ino
->uid
= cpu_to_le32(i_uid_read(inode
));
463 ino
->gid
= cpu_to_le32(i_gid_read(inode
));
464 ino
->mode
= cpu_to_le32(inode
->i_mode
);
465 ino
->flags
= cpu_to_le32(ui
->flags
);
466 ino
->size
= cpu_to_le64(ui
->ui_size
);
467 ino
->nlink
= cpu_to_le32(inode
->i_nlink
);
468 ino
->compr_type
= cpu_to_le16(ui
->compr_type
);
469 ino
->data_len
= cpu_to_le32(ui
->data_len
);
470 ino
->xattr_cnt
= cpu_to_le32(ui
->xattr_cnt
);
471 ino
->xattr_size
= cpu_to_le32(ui
->xattr_size
);
472 ino
->xattr_names
= cpu_to_le32(ui
->xattr_names
);
473 zero_ino_node_unused(ino
);
476 * Drop the attached data if this is a deletion inode, the data is not
479 if (!last_reference
) {
480 memcpy(ino
->data
, ui
->data
, ui
->data_len
);
481 data_len
= ui
->data_len
;
484 ubifs_prep_grp_node(c
, ino
, UBIFS_INO_NODE_SZ
+ data_len
, last
);
488 * mark_inode_clean - mark UBIFS inode as clean.
489 * @c: UBIFS file-system description object
490 * @ui: UBIFS inode to mark as clean
492 * This helper function marks UBIFS inode @ui as clean by cleaning the
493 * @ui->dirty flag and releasing its budget. Note, VFS may still treat the
494 * inode as dirty and try to write it back, but 'ubifs_write_inode()' would
497 static void mark_inode_clean(struct ubifs_info
*c
, struct ubifs_inode
*ui
)
500 ubifs_release_dirty_inode_budget(c
, ui
);
505 * ubifs_jnl_update - update inode.
506 * @c: UBIFS file-system description object
507 * @dir: parent inode or host inode in case of extended attributes
508 * @nm: directory entry name
509 * @inode: inode to update
510 * @deletion: indicates a directory entry deletion i.e unlink or rmdir
511 * @xent: non-zero if the directory entry is an extended attribute entry
513 * This function updates an inode by writing a directory entry (or extended
514 * attribute entry), the inode itself, and the parent directory inode (or the
515 * host inode) to the journal.
517 * The function writes the host inode @dir last, which is important in case of
518 * extended attributes. Indeed, then we guarantee that if the host inode gets
519 * synchronized (with 'fsync()'), and the write-buffer it sits in gets flushed,
520 * the extended attribute inode gets flushed too. And this is exactly what the
521 * user expects - synchronizing the host inode synchronizes its extended
522 * attributes. Similarly, this guarantees that if @dir is synchronized, its
523 * directory entry corresponding to @nm gets synchronized too.
525 * If the inode (@inode) or the parent directory (@dir) are synchronous, this
526 * function synchronizes the write-buffer.
528 * This function marks the @dir and @inode inodes as clean and returns zero on
529 * success. In case of failure, a negative error code is returned.
531 int ubifs_jnl_update(struct ubifs_info
*c
, const struct inode
*dir
,
532 const struct fscrypt_name
*nm
, const struct inode
*inode
,
533 int deletion
, int xent
)
535 int err
, dlen
, ilen
, len
, lnum
, ino_offs
, dent_offs
;
536 int aligned_dlen
, aligned_ilen
, sync
= IS_DIRSYNC(dir
);
537 int last_reference
= !!(deletion
&& inode
->i_nlink
== 0);
538 struct ubifs_inode
*ui
= ubifs_inode(inode
);
539 struct ubifs_inode
*host_ui
= ubifs_inode(dir
);
540 struct ubifs_dent_node
*dent
;
541 struct ubifs_ino_node
*ino
;
542 union ubifs_key dent_key
, ino_key
;
544 //dbg_jnl("ino %lu, dent '%.*s', data len %d in dir ino %lu",
545 // inode->i_ino, nm->len, nm->name, ui->data_len, dir->i_ino);
546 ubifs_assert(mutex_is_locked(&host_ui
->ui_mutex
));
548 dlen
= UBIFS_DENT_NODE_SZ
+ fname_len(nm
) + 1;
549 ilen
= UBIFS_INO_NODE_SZ
;
552 * If the last reference to the inode is being deleted, then there is
553 * no need to attach and write inode data, it is being deleted anyway.
554 * And if the inode is being deleted, no need to synchronize
555 * write-buffer even if the inode is synchronous.
557 if (!last_reference
) {
558 ilen
+= ui
->data_len
;
559 sync
|= IS_SYNC(inode
);
562 aligned_dlen
= ALIGN(dlen
, 8);
563 aligned_ilen
= ALIGN(ilen
, 8);
565 len
= aligned_dlen
+ aligned_ilen
+ UBIFS_INO_NODE_SZ
;
566 /* Make sure to also account for extended attributes */
567 len
+= host_ui
->data_len
;
569 dent
= kmalloc(len
, GFP_NOFS
);
573 /* Make reservation before allocating sequence numbers */
574 err
= make_reservation(c
, BASEHD
, len
);
579 dent
->ch
.node_type
= UBIFS_DENT_NODE
;
580 dent_key_init(c
, &dent_key
, dir
->i_ino
, nm
);
582 dent
->ch
.node_type
= UBIFS_XENT_NODE
;
583 xent_key_init(c
, &dent_key
, dir
->i_ino
, nm
);
586 key_write(c
, &dent_key
, dent
->key
);
587 dent
->inum
= deletion
? 0 : cpu_to_le64(inode
->i_ino
);
588 dent
->type
= get_dent_type(inode
->i_mode
);
589 dent
->nlen
= cpu_to_le16(fname_len(nm
));
590 memcpy(dent
->name
, fname_name(nm
), fname_len(nm
));
591 dent
->name
[fname_len(nm
)] = '\0';
592 dent
->cookie
= prandom_u32();
594 zero_dent_node_unused(dent
);
595 ubifs_prep_grp_node(c
, dent
, dlen
, 0);
597 ino
= (void *)dent
+ aligned_dlen
;
598 pack_inode(c
, ino
, inode
, 0);
599 ino
= (void *)ino
+ aligned_ilen
;
600 pack_inode(c
, ino
, dir
, 1);
602 if (last_reference
) {
603 err
= ubifs_add_orphan(c
, inode
->i_ino
);
605 release_head(c
, BASEHD
);
608 ui
->del_cmtno
= c
->cmt_no
;
611 err
= write_head(c
, BASEHD
, dent
, len
, &lnum
, &dent_offs
, sync
);
615 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
617 ubifs_wbuf_add_ino_nolock(wbuf
, inode
->i_ino
);
618 ubifs_wbuf_add_ino_nolock(wbuf
, dir
->i_ino
);
620 release_head(c
, BASEHD
);
624 err
= ubifs_tnc_remove_nm(c
, &dent_key
, nm
);
627 err
= ubifs_add_dirt(c
, lnum
, dlen
);
629 err
= ubifs_tnc_add_nm(c
, &dent_key
, lnum
, dent_offs
, dlen
, nm
);
634 * Note, we do not remove the inode from TNC even if the last reference
635 * to it has just been deleted, because the inode may still be opened.
636 * Instead, the inode has been added to orphan lists and the orphan
637 * subsystem will take further care about it.
639 ino_key_init(c
, &ino_key
, inode
->i_ino
);
640 ino_offs
= dent_offs
+ aligned_dlen
;
641 err
= ubifs_tnc_add(c
, &ino_key
, lnum
, ino_offs
, ilen
);
645 ino_key_init(c
, &ino_key
, dir
->i_ino
);
646 ino_offs
+= aligned_ilen
;
647 err
= ubifs_tnc_add(c
, &ino_key
, lnum
, ino_offs
,
648 UBIFS_INO_NODE_SZ
+ host_ui
->data_len
);
652 finish_reservation(c
);
653 spin_lock(&ui
->ui_lock
);
654 ui
->synced_i_size
= ui
->ui_size
;
655 spin_unlock(&ui
->ui_lock
);
656 mark_inode_clean(c
, ui
);
657 mark_inode_clean(c
, host_ui
);
661 finish_reservation(c
);
667 release_head(c
, BASEHD
);
670 ubifs_ro_mode(c
, err
);
672 ubifs_delete_orphan(c
, inode
->i_ino
);
673 finish_reservation(c
);
678 * ubifs_jnl_write_data - write a data node to the journal.
679 * @c: UBIFS file-system description object
680 * @inode: inode the data node belongs to
682 * @buf: buffer to write
683 * @len: data length (must not exceed %UBIFS_BLOCK_SIZE)
685 * This function writes a data node to the journal. Returns %0 if the data node
686 * was successfully written, and a negative error code in case of failure.
688 int ubifs_jnl_write_data(struct ubifs_info
*c
, const struct inode
*inode
,
689 const union ubifs_key
*key
, const void *buf
, int len
)
691 struct ubifs_data_node
*data
;
692 int err
, lnum
, offs
, compr_type
, out_len
, compr_len
;
693 int dlen
= COMPRESSED_DATA_NODE_BUF_SZ
, allocated
= 1;
694 struct ubifs_inode
*ui
= ubifs_inode(inode
);
695 bool encrypted
= ubifs_crypt_is_encrypted(inode
);
697 dbg_jnlk(key
, "ino %lu, blk %u, len %d, key ",
698 (unsigned long)key_inum(c
, key
), key_block(c
, key
), len
);
699 ubifs_assert(len
<= UBIFS_BLOCK_SIZE
);
702 dlen
+= UBIFS_CIPHER_BLOCK_SIZE
;
704 data
= kmalloc(dlen
, GFP_NOFS
| __GFP_NOWARN
);
707 * Fall-back to the write reserve buffer. Note, we might be
708 * currently on the memory reclaim path, when the kernel is
709 * trying to free some memory by writing out dirty pages. The
710 * write reserve buffer helps us to guarantee that we are
711 * always able to write the data.
714 mutex_lock(&c
->write_reserve_mutex
);
715 data
= c
->write_reserve_buf
;
718 data
->ch
.node_type
= UBIFS_DATA_NODE
;
719 key_write(c
, key
, &data
->key
);
720 data
->size
= cpu_to_le32(len
);
722 if (!(ui
->flags
& UBIFS_COMPR_FL
))
723 /* Compression is disabled for this inode */
724 compr_type
= UBIFS_COMPR_NONE
;
726 compr_type
= ui
->compr_type
;
728 out_len
= compr_len
= dlen
- UBIFS_DATA_NODE_SZ
;
729 ubifs_compress(c
, buf
, len
, &data
->data
, &compr_len
, &compr_type
);
730 ubifs_assert(compr_len
<= UBIFS_BLOCK_SIZE
);
733 err
= ubifs_encrypt(inode
, data
, compr_len
, &out_len
, key_block(c
, key
));
738 data
->compr_size
= 0;
741 dlen
= UBIFS_DATA_NODE_SZ
+ out_len
;
742 data
->compr_type
= cpu_to_le16(compr_type
);
744 /* Make reservation before allocating sequence numbers */
745 err
= make_reservation(c
, DATAHD
, dlen
);
749 err
= write_node(c
, DATAHD
, data
, dlen
, &lnum
, &offs
);
752 ubifs_wbuf_add_ino_nolock(&c
->jheads
[DATAHD
].wbuf
, key_inum(c
, key
));
753 release_head(c
, DATAHD
);
755 err
= ubifs_tnc_add(c
, key
, lnum
, offs
, dlen
);
759 finish_reservation(c
);
761 mutex_unlock(&c
->write_reserve_mutex
);
767 release_head(c
, DATAHD
);
769 ubifs_ro_mode(c
, err
);
770 finish_reservation(c
);
773 mutex_unlock(&c
->write_reserve_mutex
);
780 * ubifs_jnl_write_inode - flush inode to the journal.
781 * @c: UBIFS file-system description object
782 * @inode: inode to flush
784 * This function writes inode @inode to the journal. If the inode is
785 * synchronous, it also synchronizes the write-buffer. Returns zero in case of
786 * success and a negative error code in case of failure.
788 int ubifs_jnl_write_inode(struct ubifs_info
*c
, const struct inode
*inode
)
791 struct ubifs_ino_node
*ino
;
792 struct ubifs_inode
*ui
= ubifs_inode(inode
);
793 int sync
= 0, len
= UBIFS_INO_NODE_SZ
, last_reference
= !inode
->i_nlink
;
795 dbg_jnl("ino %lu, nlink %u", inode
->i_ino
, inode
->i_nlink
);
798 * If the inode is being deleted, do not write the attached data. No
799 * need to synchronize the write-buffer either.
801 if (!last_reference
) {
803 sync
= IS_SYNC(inode
);
805 ino
= kmalloc(len
, GFP_NOFS
);
809 /* Make reservation before allocating sequence numbers */
810 err
= make_reservation(c
, BASEHD
, len
);
814 pack_inode(c
, ino
, inode
, 1);
815 err
= write_head(c
, BASEHD
, ino
, len
, &lnum
, &offs
, sync
);
819 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
,
821 release_head(c
, BASEHD
);
823 if (last_reference
) {
824 err
= ubifs_tnc_remove_ino(c
, inode
->i_ino
);
827 ubifs_delete_orphan(c
, inode
->i_ino
);
828 err
= ubifs_add_dirt(c
, lnum
, len
);
832 ino_key_init(c
, &key
, inode
->i_ino
);
833 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, len
);
838 finish_reservation(c
);
839 spin_lock(&ui
->ui_lock
);
840 ui
->synced_i_size
= ui
->ui_size
;
841 spin_unlock(&ui
->ui_lock
);
846 release_head(c
, BASEHD
);
848 ubifs_ro_mode(c
, err
);
849 finish_reservation(c
);
856 * ubifs_jnl_delete_inode - delete an inode.
857 * @c: UBIFS file-system description object
858 * @inode: inode to delete
860 * This function deletes inode @inode which includes removing it from orphans,
861 * deleting it from TNC and, in some cases, writing a deletion inode to the
864 * When regular file inodes are unlinked or a directory inode is removed, the
865 * 'ubifs_jnl_update()' function writes a corresponding deletion inode and
866 * direntry to the media, and adds the inode to orphans. After this, when the
867 * last reference to this inode has been dropped, this function is called. In
868 * general, it has to write one more deletion inode to the media, because if
869 * a commit happened between 'ubifs_jnl_update()' and
870 * 'ubifs_jnl_delete_inode()', the deletion inode is not in the journal
871 * anymore, and in fact it might not be on the flash anymore, because it might
872 * have been garbage-collected already. And for optimization reasons UBIFS does
873 * not read the orphan area if it has been unmounted cleanly, so it would have
874 * no indication in the journal that there is a deleted inode which has to be
877 * However, if there was no commit between 'ubifs_jnl_update()' and
878 * 'ubifs_jnl_delete_inode()', then there is no need to write the deletion
879 * inode to the media for the second time. And this is quite a typical case.
881 * This function returns zero in case of success and a negative error code in
884 int ubifs_jnl_delete_inode(struct ubifs_info
*c
, const struct inode
*inode
)
887 struct ubifs_inode
*ui
= ubifs_inode(inode
);
889 ubifs_assert(inode
->i_nlink
== 0);
891 if (ui
->del_cmtno
!= c
->cmt_no
)
892 /* A commit happened for sure */
893 return ubifs_jnl_write_inode(c
, inode
);
895 down_read(&c
->commit_sem
);
897 * Check commit number again, because the first test has been done
898 * without @c->commit_sem, so a commit might have happened.
900 if (ui
->del_cmtno
!= c
->cmt_no
) {
901 up_read(&c
->commit_sem
);
902 return ubifs_jnl_write_inode(c
, inode
);
905 err
= ubifs_tnc_remove_ino(c
, inode
->i_ino
);
907 ubifs_ro_mode(c
, err
);
909 ubifs_delete_orphan(c
, inode
->i_ino
);
910 up_read(&c
->commit_sem
);
915 * ubifs_jnl_xrename - cross rename two directory entries.
916 * @c: UBIFS file-system description object
917 * @fst_dir: parent inode of 1st directory entry to exchange
918 * @fst_inode: 1st inode to exchange
919 * @fst_nm: name of 1st inode to exchange
920 * @snd_dir: parent inode of 2nd directory entry to exchange
921 * @snd_inode: 2nd inode to exchange
922 * @snd_nm: name of 2nd inode to exchange
923 * @sync: non-zero if the write-buffer has to be synchronized
925 * This function implements the cross rename operation which may involve
926 * writing 2 inodes and 2 directory entries. It marks the written inodes as clean
927 * and returns zero on success. In case of failure, a negative error code is
930 int ubifs_jnl_xrename(struct ubifs_info
*c
, const struct inode
*fst_dir
,
931 const struct inode
*fst_inode
,
932 const struct fscrypt_name
*fst_nm
,
933 const struct inode
*snd_dir
,
934 const struct inode
*snd_inode
,
935 const struct fscrypt_name
*snd_nm
, int sync
)
938 struct ubifs_dent_node
*dent1
, *dent2
;
939 int err
, dlen1
, dlen2
, lnum
, offs
, len
, plen
= UBIFS_INO_NODE_SZ
;
940 int aligned_dlen1
, aligned_dlen2
;
941 int twoparents
= (fst_dir
!= snd_dir
);
944 //dbg_jnl("dent '%pd' in dir ino %lu between dent '%pd' in dir ino %lu",
945 // fst_dentry, fst_dir->i_ino, snd_dentry, snd_dir->i_ino);
947 ubifs_assert(ubifs_inode(fst_dir
)->data_len
== 0);
948 ubifs_assert(ubifs_inode(snd_dir
)->data_len
== 0);
949 ubifs_assert(mutex_is_locked(&ubifs_inode(fst_dir
)->ui_mutex
));
950 ubifs_assert(mutex_is_locked(&ubifs_inode(snd_dir
)->ui_mutex
));
952 dlen1
= UBIFS_DENT_NODE_SZ
+ fname_len(snd_nm
) + 1;
953 dlen2
= UBIFS_DENT_NODE_SZ
+ fname_len(fst_nm
) + 1;
954 aligned_dlen1
= ALIGN(dlen1
, 8);
955 aligned_dlen2
= ALIGN(dlen2
, 8);
957 len
= aligned_dlen1
+ aligned_dlen2
+ ALIGN(plen
, 8);
961 dent1
= kmalloc(len
, GFP_NOFS
);
965 /* Make reservation before allocating sequence numbers */
966 err
= make_reservation(c
, BASEHD
, len
);
970 /* Make new dent for 1st entry */
971 dent1
->ch
.node_type
= UBIFS_DENT_NODE
;
972 dent_key_init_flash(c
, &dent1
->key
, snd_dir
->i_ino
, snd_nm
);
973 dent1
->inum
= cpu_to_le64(fst_inode
->i_ino
);
974 dent1
->type
= get_dent_type(fst_inode
->i_mode
);
975 dent1
->nlen
= cpu_to_le16(fname_len(snd_nm
));
976 memcpy(dent1
->name
, fname_name(snd_nm
), fname_len(snd_nm
));
977 dent1
->name
[fname_len(snd_nm
)] = '\0';
978 zero_dent_node_unused(dent1
);
979 ubifs_prep_grp_node(c
, dent1
, dlen1
, 0);
981 /* Make new dent for 2nd entry */
982 dent2
= (void *)dent1
+ aligned_dlen1
;
983 dent2
->ch
.node_type
= UBIFS_DENT_NODE
;
984 dent_key_init_flash(c
, &dent2
->key
, fst_dir
->i_ino
, fst_nm
);
985 dent2
->inum
= cpu_to_le64(snd_inode
->i_ino
);
986 dent2
->type
= get_dent_type(snd_inode
->i_mode
);
987 dent2
->nlen
= cpu_to_le16(fname_len(fst_nm
));
988 memcpy(dent2
->name
, fname_name(fst_nm
), fname_len(fst_nm
));
989 dent2
->name
[fname_len(fst_nm
)] = '\0';
990 zero_dent_node_unused(dent2
);
991 ubifs_prep_grp_node(c
, dent2
, dlen2
, 0);
993 p
= (void *)dent2
+ aligned_dlen2
;
995 pack_inode(c
, p
, fst_dir
, 1);
997 pack_inode(c
, p
, fst_dir
, 0);
999 pack_inode(c
, p
, snd_dir
, 1);
1002 err
= write_head(c
, BASEHD
, dent1
, len
, &lnum
, &offs
, sync
);
1006 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1008 ubifs_wbuf_add_ino_nolock(wbuf
, fst_dir
->i_ino
);
1009 ubifs_wbuf_add_ino_nolock(wbuf
, snd_dir
->i_ino
);
1011 release_head(c
, BASEHD
);
1013 dent_key_init(c
, &key
, snd_dir
->i_ino
, snd_nm
);
1014 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen1
, snd_nm
);
1018 offs
+= aligned_dlen1
;
1019 dent_key_init(c
, &key
, fst_dir
->i_ino
, fst_nm
);
1020 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen2
, fst_nm
);
1024 offs
+= aligned_dlen2
;
1026 ino_key_init(c
, &key
, fst_dir
->i_ino
);
1027 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
);
1032 offs
+= ALIGN(plen
, 8);
1033 ino_key_init(c
, &key
, snd_dir
->i_ino
);
1034 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
);
1039 finish_reservation(c
);
1041 mark_inode_clean(c
, ubifs_inode(fst_dir
));
1043 mark_inode_clean(c
, ubifs_inode(snd_dir
));
1048 release_head(c
, BASEHD
);
1050 ubifs_ro_mode(c
, err
);
1051 finish_reservation(c
);
1058 * ubifs_jnl_rename - rename a directory entry.
1059 * @c: UBIFS file-system description object
1060 * @old_dir: parent inode of directory entry to rename
1061 * @old_dentry: directory entry to rename
1062 * @new_dir: parent inode of directory entry to rename
1063 * @new_dentry: new directory entry (or directory entry to replace)
1064 * @sync: non-zero if the write-buffer has to be synchronized
1066 * This function implements the re-name operation which may involve writing up
1067 * to 4 inodes and 2 directory entries. It marks the written inodes as clean
1068 * and returns zero on success. In case of failure, a negative error code is
1071 int ubifs_jnl_rename(struct ubifs_info
*c
, const struct inode
*old_dir
,
1072 const struct inode
*old_inode
,
1073 const struct fscrypt_name
*old_nm
,
1074 const struct inode
*new_dir
,
1075 const struct inode
*new_inode
,
1076 const struct fscrypt_name
*new_nm
,
1077 const struct inode
*whiteout
, int sync
)
1080 union ubifs_key key
;
1081 struct ubifs_dent_node
*dent
, *dent2
;
1082 int err
, dlen1
, dlen2
, ilen
, lnum
, offs
, len
;
1083 int aligned_dlen1
, aligned_dlen2
, plen
= UBIFS_INO_NODE_SZ
;
1084 int last_reference
= !!(new_inode
&& new_inode
->i_nlink
== 0);
1085 int move
= (old_dir
!= new_dir
);
1086 struct ubifs_inode
*uninitialized_var(new_ui
);
1088 //dbg_jnl("dent '%pd' in dir ino %lu to dent '%pd' in dir ino %lu",
1089 // old_dentry, old_dir->i_ino, new_dentry, new_dir->i_ino);
1090 ubifs_assert(ubifs_inode(old_dir
)->data_len
== 0);
1091 ubifs_assert(ubifs_inode(new_dir
)->data_len
== 0);
1092 ubifs_assert(mutex_is_locked(&ubifs_inode(old_dir
)->ui_mutex
));
1093 ubifs_assert(mutex_is_locked(&ubifs_inode(new_dir
)->ui_mutex
));
1095 dlen1
= UBIFS_DENT_NODE_SZ
+ fname_len(new_nm
) + 1;
1096 dlen2
= UBIFS_DENT_NODE_SZ
+ fname_len(old_nm
) + 1;
1098 new_ui
= ubifs_inode(new_inode
);
1099 ubifs_assert(mutex_is_locked(&new_ui
->ui_mutex
));
1100 ilen
= UBIFS_INO_NODE_SZ
;
1101 if (!last_reference
)
1102 ilen
+= new_ui
->data_len
;
1106 aligned_dlen1
= ALIGN(dlen1
, 8);
1107 aligned_dlen2
= ALIGN(dlen2
, 8);
1108 len
= aligned_dlen1
+ aligned_dlen2
+ ALIGN(ilen
, 8) + ALIGN(plen
, 8);
1111 dent
= kmalloc(len
, GFP_NOFS
);
1115 /* Make reservation before allocating sequence numbers */
1116 err
= make_reservation(c
, BASEHD
, len
);
1121 dent
->ch
.node_type
= UBIFS_DENT_NODE
;
1122 dent_key_init_flash(c
, &dent
->key
, new_dir
->i_ino
, new_nm
);
1123 dent
->inum
= cpu_to_le64(old_inode
->i_ino
);
1124 dent
->type
= get_dent_type(old_inode
->i_mode
);
1125 dent
->nlen
= cpu_to_le16(fname_len(new_nm
));
1126 memcpy(dent
->name
, fname_name(new_nm
), fname_len(new_nm
));
1127 dent
->name
[fname_len(new_nm
)] = '\0';
1128 dent
->cookie
= prandom_u32();
1129 zero_dent_node_unused(dent
);
1130 ubifs_prep_grp_node(c
, dent
, dlen1
, 0);
1132 dent2
= (void *)dent
+ aligned_dlen1
;
1133 dent2
->ch
.node_type
= UBIFS_DENT_NODE
;
1134 dent_key_init_flash(c
, &dent2
->key
, old_dir
->i_ino
, old_nm
);
1137 dent2
->inum
= cpu_to_le64(whiteout
->i_ino
);
1138 dent2
->type
= get_dent_type(whiteout
->i_mode
);
1140 /* Make deletion dent */
1142 dent2
->type
= DT_UNKNOWN
;
1144 dent2
->nlen
= cpu_to_le16(fname_len(old_nm
));
1145 memcpy(dent2
->name
, fname_name(old_nm
), fname_len(old_nm
));
1146 dent2
->name
[fname_len(old_nm
)] = '\0';
1147 dent2
->cookie
= prandom_u32();
1148 zero_dent_node_unused(dent2
);
1149 ubifs_prep_grp_node(c
, dent2
, dlen2
, 0);
1151 p
= (void *)dent2
+ aligned_dlen2
;
1153 pack_inode(c
, p
, new_inode
, 0);
1154 p
+= ALIGN(ilen
, 8);
1158 pack_inode(c
, p
, old_dir
, 1);
1160 pack_inode(c
, p
, old_dir
, 0);
1161 p
+= ALIGN(plen
, 8);
1162 pack_inode(c
, p
, new_dir
, 1);
1165 if (last_reference
) {
1166 err
= ubifs_add_orphan(c
, new_inode
->i_ino
);
1168 release_head(c
, BASEHD
);
1171 new_ui
->del_cmtno
= c
->cmt_no
;
1174 err
= write_head(c
, BASEHD
, dent
, len
, &lnum
, &offs
, sync
);
1178 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1180 ubifs_wbuf_add_ino_nolock(wbuf
, new_dir
->i_ino
);
1181 ubifs_wbuf_add_ino_nolock(wbuf
, old_dir
->i_ino
);
1183 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
,
1186 release_head(c
, BASEHD
);
1188 dent_key_init(c
, &key
, new_dir
->i_ino
, new_nm
);
1189 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen1
, new_nm
);
1193 offs
+= aligned_dlen1
;
1195 dent_key_init(c
, &key
, old_dir
->i_ino
, old_nm
);
1196 err
= ubifs_tnc_add_nm(c
, &key
, lnum
, offs
, dlen2
, old_nm
);
1200 ubifs_delete_orphan(c
, whiteout
->i_ino
);
1202 err
= ubifs_add_dirt(c
, lnum
, dlen2
);
1206 dent_key_init(c
, &key
, old_dir
->i_ino
, old_nm
);
1207 err
= ubifs_tnc_remove_nm(c
, &key
, old_nm
);
1212 offs
+= aligned_dlen2
;
1214 ino_key_init(c
, &key
, new_inode
->i_ino
);
1215 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, ilen
);
1218 offs
+= ALIGN(ilen
, 8);
1221 ino_key_init(c
, &key
, old_dir
->i_ino
);
1222 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
);
1227 offs
+= ALIGN(plen
, 8);
1228 ino_key_init(c
, &key
, new_dir
->i_ino
);
1229 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, plen
);
1234 finish_reservation(c
);
1236 mark_inode_clean(c
, new_ui
);
1237 spin_lock(&new_ui
->ui_lock
);
1238 new_ui
->synced_i_size
= new_ui
->ui_size
;
1239 spin_unlock(&new_ui
->ui_lock
);
1241 mark_inode_clean(c
, ubifs_inode(old_dir
));
1243 mark_inode_clean(c
, ubifs_inode(new_dir
));
1248 release_head(c
, BASEHD
);
1250 ubifs_ro_mode(c
, err
);
1252 ubifs_delete_orphan(c
, new_inode
->i_ino
);
1254 finish_reservation(c
);
1261 * truncate_data_node - re-compress/encrypt a truncated data node.
1262 * @c: UBIFS file-system description object
1263 * @inode: inode which referes to the data node
1264 * @block: data block number
1265 * @dn: data node to re-compress
1266 * @new_len: new length
1268 * This function is used when an inode is truncated and the last data node of
1269 * the inode has to be re-compressed/encrypted and re-written.
1271 static int truncate_data_node(const struct ubifs_info
*c
, const struct inode
*inode
,
1272 unsigned int block
, struct ubifs_data_node
*dn
,
1276 int err
, dlen
, compr_type
, out_len
, old_dlen
;
1278 out_len
= le32_to_cpu(dn
->size
);
1279 buf
= kmalloc(out_len
* WORST_COMPR_FACTOR
, GFP_NOFS
);
1283 dlen
= old_dlen
= le32_to_cpu(dn
->ch
.len
) - UBIFS_DATA_NODE_SZ
;
1284 compr_type
= le16_to_cpu(dn
->compr_type
);
1286 if (ubifs_crypt_is_encrypted(inode
)) {
1287 err
= ubifs_decrypt(inode
, dn
, &dlen
, block
);
1292 if (compr_type
!= UBIFS_COMPR_NONE
) {
1293 err
= ubifs_decompress(c
, &dn
->data
, dlen
, buf
, &out_len
, compr_type
);
1297 ubifs_compress(c
, buf
, *new_len
, &dn
->data
, &out_len
, &compr_type
);
1300 if (ubifs_crypt_is_encrypted(inode
)) {
1301 err
= ubifs_encrypt(inode
, dn
, out_len
, &old_dlen
, block
);
1310 ubifs_assert(out_len
<= UBIFS_BLOCK_SIZE
);
1311 dn
->compr_type
= cpu_to_le16(compr_type
);
1312 dn
->size
= cpu_to_le32(*new_len
);
1313 *new_len
= UBIFS_DATA_NODE_SZ
+ out_len
;
1320 * ubifs_jnl_truncate - update the journal for a truncation.
1321 * @c: UBIFS file-system description object
1322 * @inode: inode to truncate
1323 * @old_size: old size
1324 * @new_size: new size
1326 * When the size of a file decreases due to truncation, a truncation node is
1327 * written, the journal tree is updated, and the last data block is re-written
1328 * if it has been affected. The inode is also updated in order to synchronize
1329 * the new inode size.
1331 * This function marks the inode as clean and returns zero on success. In case
1332 * of failure, a negative error code is returned.
1334 int ubifs_jnl_truncate(struct ubifs_info
*c
, const struct inode
*inode
,
1335 loff_t old_size
, loff_t new_size
)
1337 union ubifs_key key
, to_key
;
1338 struct ubifs_ino_node
*ino
;
1339 struct ubifs_trun_node
*trun
;
1340 struct ubifs_data_node
*uninitialized_var(dn
);
1341 int err
, dlen
, len
, lnum
, offs
, bit
, sz
, sync
= IS_SYNC(inode
);
1342 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1343 ino_t inum
= inode
->i_ino
;
1346 dbg_jnl("ino %lu, size %lld -> %lld",
1347 (unsigned long)inum
, old_size
, new_size
);
1348 ubifs_assert(!ui
->data_len
);
1349 ubifs_assert(S_ISREG(inode
->i_mode
));
1350 ubifs_assert(mutex_is_locked(&ui
->ui_mutex
));
1352 sz
= UBIFS_TRUN_NODE_SZ
+ UBIFS_INO_NODE_SZ
+
1353 UBIFS_MAX_DATA_NODE_SZ
* WORST_COMPR_FACTOR
;
1354 ino
= kmalloc(sz
, GFP_NOFS
);
1358 trun
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
1359 trun
->ch
.node_type
= UBIFS_TRUN_NODE
;
1360 trun
->inum
= cpu_to_le32(inum
);
1361 trun
->old_size
= cpu_to_le64(old_size
);
1362 trun
->new_size
= cpu_to_le64(new_size
);
1363 zero_trun_node_unused(trun
);
1365 dlen
= new_size
& (UBIFS_BLOCK_SIZE
- 1);
1367 /* Get last data block so it can be truncated */
1368 dn
= (void *)trun
+ UBIFS_TRUN_NODE_SZ
;
1369 blk
= new_size
>> UBIFS_BLOCK_SHIFT
;
1370 data_key_init(c
, &key
, inum
, blk
);
1371 dbg_jnlk(&key
, "last block key ");
1372 err
= ubifs_tnc_lookup(c
, &key
, dn
);
1374 dlen
= 0; /* Not found (so it is a hole) */
1378 if (le32_to_cpu(dn
->size
) <= dlen
)
1379 dlen
= 0; /* Nothing to do */
1381 err
= truncate_data_node(c
, inode
, blk
, dn
, &dlen
);
1388 /* Must make reservation before allocating sequence numbers */
1389 len
= UBIFS_TRUN_NODE_SZ
+ UBIFS_INO_NODE_SZ
;
1392 err
= make_reservation(c
, BASEHD
, len
);
1396 pack_inode(c
, ino
, inode
, 0);
1397 ubifs_prep_grp_node(c
, trun
, UBIFS_TRUN_NODE_SZ
, dlen
? 0 : 1);
1399 ubifs_prep_grp_node(c
, dn
, dlen
, 1);
1401 err
= write_head(c
, BASEHD
, ino
, len
, &lnum
, &offs
, sync
);
1405 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
, inum
);
1406 release_head(c
, BASEHD
);
1409 sz
= offs
+ UBIFS_INO_NODE_SZ
+ UBIFS_TRUN_NODE_SZ
;
1410 err
= ubifs_tnc_add(c
, &key
, lnum
, sz
, dlen
);
1415 ino_key_init(c
, &key
, inum
);
1416 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, UBIFS_INO_NODE_SZ
);
1420 err
= ubifs_add_dirt(c
, lnum
, UBIFS_TRUN_NODE_SZ
);
1424 bit
= new_size
& (UBIFS_BLOCK_SIZE
- 1);
1425 blk
= (new_size
>> UBIFS_BLOCK_SHIFT
) + (bit
? 1 : 0);
1426 data_key_init(c
, &key
, inum
, blk
);
1428 bit
= old_size
& (UBIFS_BLOCK_SIZE
- 1);
1429 blk
= (old_size
>> UBIFS_BLOCK_SHIFT
) - (bit
? 0 : 1);
1430 data_key_init(c
, &to_key
, inum
, blk
);
1432 err
= ubifs_tnc_remove_range(c
, &key
, &to_key
);
1436 finish_reservation(c
);
1437 spin_lock(&ui
->ui_lock
);
1438 ui
->synced_i_size
= ui
->ui_size
;
1439 spin_unlock(&ui
->ui_lock
);
1440 mark_inode_clean(c
, ui
);
1445 release_head(c
, BASEHD
);
1447 ubifs_ro_mode(c
, err
);
1448 finish_reservation(c
);
1456 * ubifs_jnl_delete_xattr - delete an extended attribute.
1457 * @c: UBIFS file-system description object
1459 * @inode: extended attribute inode
1460 * @nm: extended attribute entry name
1462 * This function delete an extended attribute which is very similar to
1463 * un-linking regular files - it writes a deletion xentry, a deletion inode and
1464 * updates the target inode. Returns zero in case of success and a negative
1465 * error code in case of failure.
1467 int ubifs_jnl_delete_xattr(struct ubifs_info
*c
, const struct inode
*host
,
1468 const struct inode
*inode
,
1469 const struct fscrypt_name
*nm
)
1471 int err
, xlen
, hlen
, len
, lnum
, xent_offs
, aligned_xlen
;
1472 struct ubifs_dent_node
*xent
;
1473 struct ubifs_ino_node
*ino
;
1474 union ubifs_key xent_key
, key1
, key2
;
1475 int sync
= IS_DIRSYNC(host
);
1476 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
1478 //dbg_jnl("host %lu, xattr ino %lu, name '%s', data len %d",
1479 // host->i_ino, inode->i_ino, nm->name,
1480 // ubifs_inode(inode)->data_len);
1481 ubifs_assert(inode
->i_nlink
== 0);
1482 ubifs_assert(mutex_is_locked(&host_ui
->ui_mutex
));
1485 * Since we are deleting the inode, we do not bother to attach any data
1486 * to it and assume its length is %UBIFS_INO_NODE_SZ.
1488 xlen
= UBIFS_DENT_NODE_SZ
+ fname_len(nm
) + 1;
1489 aligned_xlen
= ALIGN(xlen
, 8);
1490 hlen
= host_ui
->data_len
+ UBIFS_INO_NODE_SZ
;
1491 len
= aligned_xlen
+ UBIFS_INO_NODE_SZ
+ ALIGN(hlen
, 8);
1493 xent
= kmalloc(len
, GFP_NOFS
);
1497 /* Make reservation before allocating sequence numbers */
1498 err
= make_reservation(c
, BASEHD
, len
);
1504 xent
->ch
.node_type
= UBIFS_XENT_NODE
;
1505 xent_key_init(c
, &xent_key
, host
->i_ino
, nm
);
1506 key_write(c
, &xent_key
, xent
->key
);
1508 xent
->type
= get_dent_type(inode
->i_mode
);
1509 xent
->nlen
= cpu_to_le16(fname_len(nm
));
1510 memcpy(xent
->name
, fname_name(nm
), fname_len(nm
));
1511 xent
->name
[fname_len(nm
)] = '\0';
1512 zero_dent_node_unused(xent
);
1513 ubifs_prep_grp_node(c
, xent
, xlen
, 0);
1515 ino
= (void *)xent
+ aligned_xlen
;
1516 pack_inode(c
, ino
, inode
, 0);
1517 ino
= (void *)ino
+ UBIFS_INO_NODE_SZ
;
1518 pack_inode(c
, ino
, host
, 1);
1520 err
= write_head(c
, BASEHD
, xent
, len
, &lnum
, &xent_offs
, sync
);
1522 ubifs_wbuf_add_ino_nolock(&c
->jheads
[BASEHD
].wbuf
, host
->i_ino
);
1523 release_head(c
, BASEHD
);
1528 /* Remove the extended attribute entry from TNC */
1529 err
= ubifs_tnc_remove_nm(c
, &xent_key
, nm
);
1532 err
= ubifs_add_dirt(c
, lnum
, xlen
);
1537 * Remove all nodes belonging to the extended attribute inode from TNC.
1538 * Well, there actually must be only one node - the inode itself.
1540 lowest_ino_key(c
, &key1
, inode
->i_ino
);
1541 highest_ino_key(c
, &key2
, inode
->i_ino
);
1542 err
= ubifs_tnc_remove_range(c
, &key1
, &key2
);
1545 err
= ubifs_add_dirt(c
, lnum
, UBIFS_INO_NODE_SZ
);
1549 /* And update TNC with the new host inode position */
1550 ino_key_init(c
, &key1
, host
->i_ino
);
1551 err
= ubifs_tnc_add(c
, &key1
, lnum
, xent_offs
+ len
- hlen
, hlen
);
1555 finish_reservation(c
);
1556 spin_lock(&host_ui
->ui_lock
);
1557 host_ui
->synced_i_size
= host_ui
->ui_size
;
1558 spin_unlock(&host_ui
->ui_lock
);
1559 mark_inode_clean(c
, host_ui
);
1563 ubifs_ro_mode(c
, err
);
1564 finish_reservation(c
);
1569 * ubifs_jnl_change_xattr - change an extended attribute.
1570 * @c: UBIFS file-system description object
1571 * @inode: extended attribute inode
1574 * This function writes the updated version of an extended attribute inode and
1575 * the host inode to the journal (to the base head). The host inode is written
1576 * after the extended attribute inode in order to guarantee that the extended
1577 * attribute will be flushed when the inode is synchronized by 'fsync()' and
1578 * consequently, the write-buffer is synchronized. This function returns zero
1579 * in case of success and a negative error code in case of failure.
1581 int ubifs_jnl_change_xattr(struct ubifs_info
*c
, const struct inode
*inode
,
1582 const struct inode
*host
)
1584 int err
, len1
, len2
, aligned_len
, aligned_len1
, lnum
, offs
;
1585 struct ubifs_inode
*host_ui
= ubifs_inode(host
);
1586 struct ubifs_ino_node
*ino
;
1587 union ubifs_key key
;
1588 int sync
= IS_DIRSYNC(host
);
1590 dbg_jnl("ino %lu, ino %lu", host
->i_ino
, inode
->i_ino
);
1591 ubifs_assert(host
->i_nlink
> 0);
1592 ubifs_assert(inode
->i_nlink
> 0);
1593 ubifs_assert(mutex_is_locked(&host_ui
->ui_mutex
));
1595 len1
= UBIFS_INO_NODE_SZ
+ host_ui
->data_len
;
1596 len2
= UBIFS_INO_NODE_SZ
+ ubifs_inode(inode
)->data_len
;
1597 aligned_len1
= ALIGN(len1
, 8);
1598 aligned_len
= aligned_len1
+ ALIGN(len2
, 8);
1600 ino
= kmalloc(aligned_len
, GFP_NOFS
);
1604 /* Make reservation before allocating sequence numbers */
1605 err
= make_reservation(c
, BASEHD
, aligned_len
);
1609 pack_inode(c
, ino
, host
, 0);
1610 pack_inode(c
, (void *)ino
+ aligned_len1
, inode
, 1);
1612 err
= write_head(c
, BASEHD
, ino
, aligned_len
, &lnum
, &offs
, 0);
1613 if (!sync
&& !err
) {
1614 struct ubifs_wbuf
*wbuf
= &c
->jheads
[BASEHD
].wbuf
;
1616 ubifs_wbuf_add_ino_nolock(wbuf
, host
->i_ino
);
1617 ubifs_wbuf_add_ino_nolock(wbuf
, inode
->i_ino
);
1619 release_head(c
, BASEHD
);
1623 ino_key_init(c
, &key
, host
->i_ino
);
1624 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
, len1
);
1628 ino_key_init(c
, &key
, inode
->i_ino
);
1629 err
= ubifs_tnc_add(c
, &key
, lnum
, offs
+ aligned_len1
, len2
);
1633 finish_reservation(c
);
1634 spin_lock(&host_ui
->ui_lock
);
1635 host_ui
->synced_i_size
= host_ui
->ui_size
;
1636 spin_unlock(&host_ui
->ui_lock
);
1637 mark_inode_clean(c
, host_ui
);
1642 ubifs_ro_mode(c
, err
);
1643 finish_reservation(c
);