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()'. Returns zero in case of success, %-EAGAIN if commit has to
102 * be done, and other negative error codes in case of other failures.
104 static int reserve_space(struct ubifs_info *c, int jhead, int len)
106 int err = 0, err1, retries = 0, avail, lnum, offs, squeeze;
107 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
110 * Typically, the base head has smaller nodes written to it, so it is
111 * better to try to allocate space at the ends of eraseblocks. This is
112 * what the squeeze parameter does.
114 ubifs_assert(!c->ro_media && !c->ro_mount);
115 squeeze = (jhead == BASEHD);
117 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
124 avail = c->leb_size - wbuf->offs - wbuf->used;
125 if (wbuf->lnum != -1 && avail >= len)
129 * Write buffer wasn't seek'ed or there is no enough space - look for an
130 * LEB with some empty space.
132 lnum = ubifs_find_free_space(c, len, &offs, squeeze);
141 * No free space, we have to run garbage collector to make
142 * some. But the write-buffer mutex has to be unlocked because
145 dbg_jnl("no free space in jhead %s, run GC", dbg_jhead(jhead));
146 mutex_unlock(&wbuf->io_mutex);
148 lnum = ubifs_garbage_collect(c, 0);
155 * GC could not make a free LEB. But someone else may
156 * have allocated new bud for this journal head,
157 * because we dropped @wbuf->io_mutex, so try once
160 dbg_jnl("GC couldn't make a free LEB for jhead %s",
163 dbg_jnl("retry (%d)", retries);
167 dbg_jnl("return -ENOSPC");
171 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
172 dbg_jnl("got LEB %d for jhead %s", lnum, dbg_jhead(jhead));
173 avail = c->leb_size - wbuf->offs - wbuf->used;
175 if (wbuf->lnum != -1 && avail >= len) {
177 * Someone else has switched the journal head and we have
178 * enough space now. This happens when more than one process is
179 * trying to write to the same journal head at the same time.
181 dbg_jnl("return LEB %d back, already have LEB %d:%d",
182 lnum, wbuf->lnum, wbuf->offs + wbuf->used);
183 err = ubifs_return_leb(c, lnum);
193 * Make sure we synchronize the write-buffer before we add the new bud
194 * to the log. Otherwise we may have a power cut after the log
195 * reference node for the last bud (@lnum) is written but before the
196 * write-buffer data are written to the next-to-last bud
197 * (@wbuf->lnum). And the effect would be that the recovery would see
198 * that there is corruption in the next-to-last bud.
200 err = ubifs_wbuf_sync_nolock(wbuf);
203 err = ubifs_add_bud_to_log(c, jhead, lnum, offs);
206 err = ubifs_wbuf_seek_nolock(wbuf, lnum, offs);
213 mutex_unlock(&wbuf->io_mutex);
217 /* An error occurred and the LEB has to be returned to lprops */
218 ubifs_assert(err < 0);
219 err1 = ubifs_return_leb(c, lnum);
220 if (err1 && err == -EAGAIN)
222 * Return original error code only if it is not %-EAGAIN,
223 * which is not really an error. Otherwise, return the error
224 * code of 'ubifs_return_leb()'.
227 mutex_unlock(&wbuf->io_mutex);
232 * write_node - write node to a journal head.
233 * @c: UBIFS file-system description object
234 * @jhead: journal head
235 * @node: node to write
237 * @lnum: LEB number written is returned here
238 * @offs: offset written is returned here
240 * This function writes a node to reserved space of journal head @jhead.
241 * Returns zero in case of success and a negative error code in case of
244 static int write_node(struct ubifs_info *c, int jhead, void *node, int len,
245 int *lnum, int *offs)
247 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
249 ubifs_assert(jhead != GCHD);
251 *lnum = c->jheads[jhead].wbuf.lnum;
252 *offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
254 dbg_jnl("jhead %s, LEB %d:%d, len %d",
255 dbg_jhead(jhead), *lnum, *offs, len);
256 ubifs_prepare_node(c, node, len, 0);
258 return ubifs_wbuf_write_nolock(wbuf, node, len);
262 * write_head - write data to a journal head.
263 * @c: UBIFS file-system description object
264 * @jhead: journal head
265 * @buf: buffer to write
266 * @len: length to write
267 * @lnum: LEB number written is returned here
268 * @offs: offset written is returned here
269 * @sync: non-zero if the write-buffer has to by synchronized
271 * This function is the same as 'write_node()' but it does not assume the
272 * buffer it is writing is a node, so it does not prepare it (which means
273 * initializing common header and calculating CRC).
275 static int write_head(struct ubifs_info *c, int jhead, void *buf, int len,
276 int *lnum, int *offs, int sync)
279 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
281 ubifs_assert(jhead != GCHD);
283 *lnum = c->jheads[jhead].wbuf.lnum;
284 *offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
285 dbg_jnl("jhead %s, LEB %d:%d, len %d",
286 dbg_jhead(jhead), *lnum, *offs, len);
288 err = ubifs_wbuf_write_nolock(wbuf, buf, len);
292 err = ubifs_wbuf_sync_nolock(wbuf);
297 * make_reservation - reserve journal space.
298 * @c: UBIFS file-system description object
299 * @jhead: journal head
300 * @len: how many bytes to reserve
302 * This function makes space reservation in journal head @jhead. The function
303 * takes the commit lock and locks the journal head, and the caller has to
304 * unlock the head and finish the reservation with 'finish_reservation()'.
305 * Returns zero in case of success and a negative error code in case of
308 * Note, the journal head may be unlocked as soon as the data is written, while
309 * the commit lock has to be released after the data has been added to the
312 static int make_reservation(struct ubifs_info *c, int jhead, int len)
314 int err, cmt_retries = 0, nospc_retries = 0;
317 down_read(&c->commit_sem);
318 err = reserve_space(c, jhead, len);
321 up_read(&c->commit_sem);
323 if (err == -ENOSPC) {
325 * GC could not make any progress. We should try to commit
326 * once because it could make some dirty space and GC would
327 * make progress, so make the error -EAGAIN so that the below
328 * will commit and re-try.
330 if (nospc_retries++ < 2) {
331 dbg_jnl("no space, retry");
336 * This means that the budgeting is incorrect. We always have
337 * to be able to write to the media, because all operations are
338 * budgeted. Deletions are not budgeted, though, but we reserve
339 * an extra LEB for them.
347 * -EAGAIN means that the journal is full or too large, or the above
348 * code wants to do one commit. Do this and re-try.
350 if (cmt_retries > 128) {
352 * This should not happen unless the journal size limitations
355 ubifs_err(c, "stuck in space allocation");
358 } else if (cmt_retries > 32)
359 ubifs_warn(c, "too many space allocation re-tries (%d)",
362 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
366 err = ubifs_run_commit(c);
372 ubifs_err(c, "cannot reserve %d bytes in jhead %d, error %d",
374 if (err == -ENOSPC) {
375 /* This are some budgeting problems, print useful information */
376 down_write(&c->commit_sem);
378 ubifs_dump_budg(c, &c->bi);
379 ubifs_dump_lprops(c);
380 cmt_retries = dbg_check_lprops(c);
381 up_write(&c->commit_sem);
387 * release_head - release a journal head.
388 * @c: UBIFS file-system description object
389 * @jhead: journal head
391 * This function releases journal head @jhead which was locked by
392 * the 'make_reservation()' function. It has to be called after each successful
393 * 'make_reservation()' invocation.
395 static inline void release_head(struct ubifs_info *c, int jhead)
397 mutex_unlock(&c->jheads[jhead].wbuf.io_mutex);
401 * finish_reservation - finish a reservation.
402 * @c: UBIFS file-system description object
404 * This function finishes journal space reservation. It must be called after
405 * 'make_reservation()'.
407 static void finish_reservation(struct ubifs_info *c)
409 up_read(&c->commit_sem);
413 * get_dent_type - translate VFS inode mode to UBIFS directory entry type.
416 static int get_dent_type(int mode)
418 switch (mode & S_IFMT) {
420 return UBIFS_ITYPE_REG;
422 return UBIFS_ITYPE_DIR;
424 return UBIFS_ITYPE_LNK;
426 return UBIFS_ITYPE_BLK;
428 return UBIFS_ITYPE_CHR;
430 return UBIFS_ITYPE_FIFO;
432 return UBIFS_ITYPE_SOCK;
440 * pack_inode - pack an inode node.
441 * @c: UBIFS file-system description object
442 * @ino: buffer in which to pack inode node
443 * @inode: inode to pack
444 * @last: indicates the last node of the group
446 static void pack_inode(struct ubifs_info *c, struct ubifs_ino_node *ino,
447 const struct inode *inode, int last)
449 int data_len = 0, last_reference = !inode->i_nlink;
450 struct ubifs_inode *ui = ubifs_inode(inode);
452 ino->ch.node_type = UBIFS_INO_NODE;
453 ino_key_init_flash(c, &ino->key, inode->i_ino);
454 ino->creat_sqnum = cpu_to_le64(ui->creat_sqnum);
455 ino->atime_sec = cpu_to_le64(inode->i_atime.tv_sec);
456 ino->atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
457 ino->ctime_sec = cpu_to_le64(inode->i_ctime.tv_sec);
458 ino->ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
459 ino->mtime_sec = cpu_to_le64(inode->i_mtime.tv_sec);
460 ino->mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
461 ino->uid = cpu_to_le32(i_uid_read(inode));
462 ino->gid = cpu_to_le32(i_gid_read(inode));
463 ino->mode = cpu_to_le32(inode->i_mode);
464 ino->flags = cpu_to_le32(ui->flags);
465 ino->size = cpu_to_le64(ui->ui_size);
466 ino->nlink = cpu_to_le32(inode->i_nlink);
467 ino->compr_type = cpu_to_le16(ui->compr_type);
468 ino->data_len = cpu_to_le32(ui->data_len);
469 ino->xattr_cnt = cpu_to_le32(ui->xattr_cnt);
470 ino->xattr_size = cpu_to_le32(ui->xattr_size);
471 ino->xattr_names = cpu_to_le32(ui->xattr_names);
472 zero_ino_node_unused(ino);
475 * Drop the attached data if this is a deletion inode, the data is not
478 if (!last_reference) {
479 memcpy(ino->data, ui->data, ui->data_len);
480 data_len = ui->data_len;
483 ubifs_prep_grp_node(c, ino, UBIFS_INO_NODE_SZ + data_len, last);
487 * mark_inode_clean - mark UBIFS inode as clean.
488 * @c: UBIFS file-system description object
489 * @ui: UBIFS inode to mark as clean
491 * This helper function marks UBIFS inode @ui as clean by cleaning the
492 * @ui->dirty flag and releasing its budget. Note, VFS may still treat the
493 * inode as dirty and try to write it back, but 'ubifs_write_inode()' would
496 static void mark_inode_clean(struct ubifs_info *c, struct ubifs_inode *ui)
499 ubifs_release_dirty_inode_budget(c, ui);
503 static void set_dent_cookie(struct ubifs_info *c, struct ubifs_dent_node *dent)
506 dent->cookie = prandom_u32();
512 * ubifs_jnl_update - update inode.
513 * @c: UBIFS file-system description object
514 * @dir: parent inode or host inode in case of extended attributes
515 * @nm: directory entry name
516 * @inode: inode to update
517 * @deletion: indicates a directory entry deletion i.e unlink or rmdir
518 * @xent: non-zero if the directory entry is an extended attribute entry
520 * This function updates an inode by writing a directory entry (or extended
521 * attribute entry), the inode itself, and the parent directory inode (or the
522 * host inode) to the journal.
524 * The function writes the host inode @dir last, which is important in case of
525 * extended attributes. Indeed, then we guarantee that if the host inode gets
526 * synchronized (with 'fsync()'), and the write-buffer it sits in gets flushed,
527 * the extended attribute inode gets flushed too. And this is exactly what the
528 * user expects - synchronizing the host inode synchronizes its extended
529 * attributes. Similarly, this guarantees that if @dir is synchronized, its
530 * directory entry corresponding to @nm gets synchronized too.
532 * If the inode (@inode) or the parent directory (@dir) are synchronous, this
533 * function synchronizes the write-buffer.
535 * This function marks the @dir and @inode inodes as clean and returns zero on
536 * success. In case of failure, a negative error code is returned.
538 int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,
539 const struct fscrypt_name *nm, const struct inode *inode,
540 int deletion, int xent)
542 int err, dlen, ilen, len, lnum, ino_offs, dent_offs;
543 int aligned_dlen, aligned_ilen, sync = IS_DIRSYNC(dir);
544 int last_reference = !!(deletion && inode->i_nlink == 0);
545 struct ubifs_inode *ui = ubifs_inode(inode);
546 struct ubifs_inode *host_ui = ubifs_inode(dir);
547 struct ubifs_dent_node *dent;
548 struct ubifs_ino_node *ino;
549 union ubifs_key dent_key, ino_key;
551 ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
553 dlen = UBIFS_DENT_NODE_SZ + fname_len(nm) + 1;
554 ilen = UBIFS_INO_NODE_SZ;
557 * If the last reference to the inode is being deleted, then there is
558 * no need to attach and write inode data, it is being deleted anyway.
559 * And if the inode is being deleted, no need to synchronize
560 * write-buffer even if the inode is synchronous.
562 if (!last_reference) {
563 ilen += ui->data_len;
564 sync |= IS_SYNC(inode);
567 aligned_dlen = ALIGN(dlen, 8);
568 aligned_ilen = ALIGN(ilen, 8);
570 len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
571 /* Make sure to also account for extended attributes */
572 len += host_ui->data_len;
574 dent = kzalloc(len, GFP_NOFS);
578 /* Make reservation before allocating sequence numbers */
579 err = make_reservation(c, BASEHD, len);
584 dent->ch.node_type = UBIFS_DENT_NODE;
586 dent_key_init_hash(c, &dent_key, dir->i_ino, nm->hash);
588 dent_key_init(c, &dent_key, dir->i_ino, nm);
590 dent->ch.node_type = UBIFS_XENT_NODE;
591 xent_key_init(c, &dent_key, dir->i_ino, nm);
594 key_write(c, &dent_key, dent->key);
595 dent->inum = deletion ? 0 : cpu_to_le64(inode->i_ino);
596 dent->type = get_dent_type(inode->i_mode);
597 dent->nlen = cpu_to_le16(fname_len(nm));
598 memcpy(dent->name, fname_name(nm), fname_len(nm));
599 dent->name[fname_len(nm)] = '\0';
600 set_dent_cookie(c, dent);
602 zero_dent_node_unused(dent);
603 ubifs_prep_grp_node(c, dent, dlen, 0);
605 ino = (void *)dent + aligned_dlen;
606 pack_inode(c, ino, inode, 0);
607 ino = (void *)ino + aligned_ilen;
608 pack_inode(c, ino, dir, 1);
610 if (last_reference) {
611 err = ubifs_add_orphan(c, inode->i_ino);
613 release_head(c, BASEHD);
616 ui->del_cmtno = c->cmt_no;
619 err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
623 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
625 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
626 ubifs_wbuf_add_ino_nolock(wbuf, dir->i_ino);
628 release_head(c, BASEHD);
633 err = ubifs_tnc_remove_dh(c, &dent_key, nm->minor_hash);
635 err = ubifs_tnc_remove_nm(c, &dent_key, nm);
638 err = ubifs_add_dirt(c, lnum, dlen);
640 err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen, nm);
645 * Note, we do not remove the inode from TNC even if the last reference
646 * to it has just been deleted, because the inode may still be opened.
647 * Instead, the inode has been added to orphan lists and the orphan
648 * subsystem will take further care about it.
650 ino_key_init(c, &ino_key, inode->i_ino);
651 ino_offs = dent_offs + aligned_dlen;
652 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen);
656 ino_key_init(c, &ino_key, dir->i_ino);
657 ino_offs += aligned_ilen;
658 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs,
659 UBIFS_INO_NODE_SZ + host_ui->data_len);
663 finish_reservation(c);
664 spin_lock(&ui->ui_lock);
665 ui->synced_i_size = ui->ui_size;
666 spin_unlock(&ui->ui_lock);
667 mark_inode_clean(c, ui);
668 mark_inode_clean(c, host_ui);
672 finish_reservation(c);
678 release_head(c, BASEHD);
681 ubifs_ro_mode(c, err);
683 ubifs_delete_orphan(c, inode->i_ino);
684 finish_reservation(c);
689 * ubifs_jnl_write_data - write a data node to the journal.
690 * @c: UBIFS file-system description object
691 * @inode: inode the data node belongs to
693 * @buf: buffer to write
694 * @len: data length (must not exceed %UBIFS_BLOCK_SIZE)
696 * This function writes a data node to the journal. Returns %0 if the data node
697 * was successfully written, and a negative error code in case of failure.
699 int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
700 const union ubifs_key *key, const void *buf, int len)
702 struct ubifs_data_node *data;
703 int err, lnum, offs, compr_type, out_len, compr_len;
704 int dlen = COMPRESSED_DATA_NODE_BUF_SZ, allocated = 1;
705 struct ubifs_inode *ui = ubifs_inode(inode);
706 bool encrypted = ubifs_crypt_is_encrypted(inode);
708 dbg_jnlk(key, "ino %lu, blk %u, len %d, key ",
709 (unsigned long)key_inum(c, key), key_block(c, key), len);
710 ubifs_assert(len <= UBIFS_BLOCK_SIZE);
713 dlen += UBIFS_CIPHER_BLOCK_SIZE;
715 data = kmalloc(dlen, GFP_NOFS | __GFP_NOWARN);
718 * Fall-back to the write reserve buffer. Note, we might be
719 * currently on the memory reclaim path, when the kernel is
720 * trying to free some memory by writing out dirty pages. The
721 * write reserve buffer helps us to guarantee that we are
722 * always able to write the data.
725 mutex_lock(&c->write_reserve_mutex);
726 data = c->write_reserve_buf;
729 data->ch.node_type = UBIFS_DATA_NODE;
730 key_write(c, key, &data->key);
731 data->size = cpu_to_le32(len);
733 if (!(ui->flags & UBIFS_COMPR_FL))
734 /* Compression is disabled for this inode */
735 compr_type = UBIFS_COMPR_NONE;
737 compr_type = ui->compr_type;
739 out_len = compr_len = dlen - UBIFS_DATA_NODE_SZ;
740 ubifs_compress(c, buf, len, &data->data, &compr_len, &compr_type);
741 ubifs_assert(compr_len <= UBIFS_BLOCK_SIZE);
744 err = ubifs_encrypt(inode, data, compr_len, &out_len, key_block(c, key));
749 data->compr_size = 0;
753 dlen = UBIFS_DATA_NODE_SZ + out_len;
754 data->compr_type = cpu_to_le16(compr_type);
756 /* Make reservation before allocating sequence numbers */
757 err = make_reservation(c, DATAHD, dlen);
761 err = write_node(c, DATAHD, data, dlen, &lnum, &offs);
764 ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf, key_inum(c, key));
765 release_head(c, DATAHD);
767 err = ubifs_tnc_add(c, key, lnum, offs, dlen);
771 finish_reservation(c);
773 mutex_unlock(&c->write_reserve_mutex);
779 release_head(c, DATAHD);
781 ubifs_ro_mode(c, err);
782 finish_reservation(c);
785 mutex_unlock(&c->write_reserve_mutex);
792 * ubifs_jnl_write_inode - flush inode to the journal.
793 * @c: UBIFS file-system description object
794 * @inode: inode to flush
796 * This function writes inode @inode to the journal. If the inode is
797 * synchronous, it also synchronizes the write-buffer. Returns zero in case of
798 * success and a negative error code in case of failure.
800 int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode)
803 struct ubifs_ino_node *ino;
804 struct ubifs_inode *ui = ubifs_inode(inode);
805 int sync = 0, len = UBIFS_INO_NODE_SZ, last_reference = !inode->i_nlink;
807 dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
810 * If the inode is being deleted, do not write the attached data. No
811 * need to synchronize the write-buffer either.
813 if (!last_reference) {
815 sync = IS_SYNC(inode);
817 ino = kmalloc(len, GFP_NOFS);
821 /* Make reservation before allocating sequence numbers */
822 err = make_reservation(c, BASEHD, len);
826 pack_inode(c, ino, inode, 1);
827 err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
831 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
833 release_head(c, BASEHD);
835 if (last_reference) {
836 err = ubifs_tnc_remove_ino(c, inode->i_ino);
839 ubifs_delete_orphan(c, inode->i_ino);
840 err = ubifs_add_dirt(c, lnum, len);
844 ino_key_init(c, &key, inode->i_ino);
845 err = ubifs_tnc_add(c, &key, lnum, offs, len);
850 finish_reservation(c);
851 spin_lock(&ui->ui_lock);
852 ui->synced_i_size = ui->ui_size;
853 spin_unlock(&ui->ui_lock);
858 release_head(c, BASEHD);
860 ubifs_ro_mode(c, err);
861 finish_reservation(c);
868 * ubifs_jnl_delete_inode - delete an inode.
869 * @c: UBIFS file-system description object
870 * @inode: inode to delete
872 * This function deletes inode @inode which includes removing it from orphans,
873 * deleting it from TNC and, in some cases, writing a deletion inode to the
876 * When regular file inodes are unlinked or a directory inode is removed, the
877 * 'ubifs_jnl_update()' function writes a corresponding deletion inode and
878 * direntry to the media, and adds the inode to orphans. After this, when the
879 * last reference to this inode has been dropped, this function is called. In
880 * general, it has to write one more deletion inode to the media, because if
881 * a commit happened between 'ubifs_jnl_update()' and
882 * 'ubifs_jnl_delete_inode()', the deletion inode is not in the journal
883 * anymore, and in fact it might not be on the flash anymore, because it might
884 * have been garbage-collected already. And for optimization reasons UBIFS does
885 * not read the orphan area if it has been unmounted cleanly, so it would have
886 * no indication in the journal that there is a deleted inode which has to be
889 * However, if there was no commit between 'ubifs_jnl_update()' and
890 * 'ubifs_jnl_delete_inode()', then there is no need to write the deletion
891 * inode to the media for the second time. And this is quite a typical case.
893 * This function returns zero in case of success and a negative error code in
896 int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode)
899 struct ubifs_inode *ui = ubifs_inode(inode);
901 ubifs_assert(inode->i_nlink == 0);
903 if (ui->del_cmtno != c->cmt_no)
904 /* A commit happened for sure */
905 return ubifs_jnl_write_inode(c, inode);
907 down_read(&c->commit_sem);
909 * Check commit number again, because the first test has been done
910 * without @c->commit_sem, so a commit might have happened.
912 if (ui->del_cmtno != c->cmt_no) {
913 up_read(&c->commit_sem);
914 return ubifs_jnl_write_inode(c, inode);
917 err = ubifs_tnc_remove_ino(c, inode->i_ino);
919 ubifs_ro_mode(c, err);
921 ubifs_delete_orphan(c, inode->i_ino);
922 up_read(&c->commit_sem);
927 * ubifs_jnl_xrename - cross rename two directory entries.
928 * @c: UBIFS file-system description object
929 * @fst_dir: parent inode of 1st directory entry to exchange
930 * @fst_inode: 1st inode to exchange
931 * @fst_nm: name of 1st inode to exchange
932 * @snd_dir: parent inode of 2nd directory entry to exchange
933 * @snd_inode: 2nd inode to exchange
934 * @snd_nm: name of 2nd inode to exchange
935 * @sync: non-zero if the write-buffer has to be synchronized
937 * This function implements the cross rename operation which may involve
938 * writing 2 inodes and 2 directory entries. It marks the written inodes as clean
939 * and returns zero on success. In case of failure, a negative error code is
942 int ubifs_jnl_xrename(struct ubifs_info *c, const struct inode *fst_dir,
943 const struct inode *fst_inode,
944 const struct fscrypt_name *fst_nm,
945 const struct inode *snd_dir,
946 const struct inode *snd_inode,
947 const struct fscrypt_name *snd_nm, int sync)
950 struct ubifs_dent_node *dent1, *dent2;
951 int err, dlen1, dlen2, lnum, offs, len, plen = UBIFS_INO_NODE_SZ;
952 int aligned_dlen1, aligned_dlen2;
953 int twoparents = (fst_dir != snd_dir);
956 ubifs_assert(ubifs_inode(fst_dir)->data_len == 0);
957 ubifs_assert(ubifs_inode(snd_dir)->data_len == 0);
958 ubifs_assert(mutex_is_locked(&ubifs_inode(fst_dir)->ui_mutex));
959 ubifs_assert(mutex_is_locked(&ubifs_inode(snd_dir)->ui_mutex));
961 dlen1 = UBIFS_DENT_NODE_SZ + fname_len(snd_nm) + 1;
962 dlen2 = UBIFS_DENT_NODE_SZ + fname_len(fst_nm) + 1;
963 aligned_dlen1 = ALIGN(dlen1, 8);
964 aligned_dlen2 = ALIGN(dlen2, 8);
966 len = aligned_dlen1 + aligned_dlen2 + ALIGN(plen, 8);
970 dent1 = kzalloc(len, GFP_NOFS);
974 /* Make reservation before allocating sequence numbers */
975 err = make_reservation(c, BASEHD, len);
979 /* Make new dent for 1st entry */
980 dent1->ch.node_type = UBIFS_DENT_NODE;
981 dent_key_init_flash(c, &dent1->key, snd_dir->i_ino, snd_nm);
982 dent1->inum = cpu_to_le64(fst_inode->i_ino);
983 dent1->type = get_dent_type(fst_inode->i_mode);
984 dent1->nlen = cpu_to_le16(fname_len(snd_nm));
985 memcpy(dent1->name, fname_name(snd_nm), fname_len(snd_nm));
986 dent1->name[fname_len(snd_nm)] = '\0';
987 set_dent_cookie(c, dent1);
988 zero_dent_node_unused(dent1);
989 ubifs_prep_grp_node(c, dent1, dlen1, 0);
991 /* Make new dent for 2nd entry */
992 dent2 = (void *)dent1 + aligned_dlen1;
993 dent2->ch.node_type = UBIFS_DENT_NODE;
994 dent_key_init_flash(c, &dent2->key, fst_dir->i_ino, fst_nm);
995 dent2->inum = cpu_to_le64(snd_inode->i_ino);
996 dent2->type = get_dent_type(snd_inode->i_mode);
997 dent2->nlen = cpu_to_le16(fname_len(fst_nm));
998 memcpy(dent2->name, fname_name(fst_nm), fname_len(fst_nm));
999 dent2->name[fname_len(fst_nm)] = '\0';
1000 set_dent_cookie(c, dent2);
1001 zero_dent_node_unused(dent2);
1002 ubifs_prep_grp_node(c, dent2, dlen2, 0);
1004 p = (void *)dent2 + aligned_dlen2;
1006 pack_inode(c, p, fst_dir, 1);
1008 pack_inode(c, p, fst_dir, 0);
1009 p += ALIGN(plen, 8);
1010 pack_inode(c, p, snd_dir, 1);
1013 err = write_head(c, BASEHD, dent1, len, &lnum, &offs, sync);
1017 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1019 ubifs_wbuf_add_ino_nolock(wbuf, fst_dir->i_ino);
1020 ubifs_wbuf_add_ino_nolock(wbuf, snd_dir->i_ino);
1022 release_head(c, BASEHD);
1024 dent_key_init(c, &key, snd_dir->i_ino, snd_nm);
1025 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, snd_nm);
1029 offs += aligned_dlen1;
1030 dent_key_init(c, &key, fst_dir->i_ino, fst_nm);
1031 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, fst_nm);
1035 offs += aligned_dlen2;
1037 ino_key_init(c, &key, fst_dir->i_ino);
1038 err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1043 offs += ALIGN(plen, 8);
1044 ino_key_init(c, &key, snd_dir->i_ino);
1045 err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1050 finish_reservation(c);
1052 mark_inode_clean(c, ubifs_inode(fst_dir));
1054 mark_inode_clean(c, ubifs_inode(snd_dir));
1059 release_head(c, BASEHD);
1061 ubifs_ro_mode(c, err);
1062 finish_reservation(c);
1069 * ubifs_jnl_rename - rename a directory entry.
1070 * @c: UBIFS file-system description object
1071 * @old_dir: parent inode of directory entry to rename
1072 * @old_dentry: directory entry to rename
1073 * @new_dir: parent inode of directory entry to rename
1074 * @new_dentry: new directory entry (or directory entry to replace)
1075 * @sync: non-zero if the write-buffer has to be synchronized
1077 * This function implements the re-name operation which may involve writing up
1078 * to 4 inodes and 2 directory entries. It marks the written inodes as clean
1079 * and returns zero on success. In case of failure, a negative error code is
1082 int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
1083 const struct inode *old_inode,
1084 const struct fscrypt_name *old_nm,
1085 const struct inode *new_dir,
1086 const struct inode *new_inode,
1087 const struct fscrypt_name *new_nm,
1088 const struct inode *whiteout, int sync)
1091 union ubifs_key key;
1092 struct ubifs_dent_node *dent, *dent2;
1093 int err, dlen1, dlen2, ilen, lnum, offs, len;
1094 int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
1095 int last_reference = !!(new_inode && new_inode->i_nlink == 0);
1096 int move = (old_dir != new_dir);
1097 struct ubifs_inode *uninitialized_var(new_ui);
1099 ubifs_assert(ubifs_inode(old_dir)->data_len == 0);
1100 ubifs_assert(ubifs_inode(new_dir)->data_len == 0);
1101 ubifs_assert(mutex_is_locked(&ubifs_inode(old_dir)->ui_mutex));
1102 ubifs_assert(mutex_is_locked(&ubifs_inode(new_dir)->ui_mutex));
1104 dlen1 = UBIFS_DENT_NODE_SZ + fname_len(new_nm) + 1;
1105 dlen2 = UBIFS_DENT_NODE_SZ + fname_len(old_nm) + 1;
1107 new_ui = ubifs_inode(new_inode);
1108 ubifs_assert(mutex_is_locked(&new_ui->ui_mutex));
1109 ilen = UBIFS_INO_NODE_SZ;
1110 if (!last_reference)
1111 ilen += new_ui->data_len;
1115 aligned_dlen1 = ALIGN(dlen1, 8);
1116 aligned_dlen2 = ALIGN(dlen2, 8);
1117 len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
1120 dent = kzalloc(len, GFP_NOFS);
1124 /* Make reservation before allocating sequence numbers */
1125 err = make_reservation(c, BASEHD, len);
1130 dent->ch.node_type = UBIFS_DENT_NODE;
1131 dent_key_init_flash(c, &dent->key, new_dir->i_ino, new_nm);
1132 dent->inum = cpu_to_le64(old_inode->i_ino);
1133 dent->type = get_dent_type(old_inode->i_mode);
1134 dent->nlen = cpu_to_le16(fname_len(new_nm));
1135 memcpy(dent->name, fname_name(new_nm), fname_len(new_nm));
1136 dent->name[fname_len(new_nm)] = '\0';
1137 set_dent_cookie(c, dent);
1138 zero_dent_node_unused(dent);
1139 ubifs_prep_grp_node(c, dent, dlen1, 0);
1141 dent2 = (void *)dent + aligned_dlen1;
1142 dent2->ch.node_type = UBIFS_DENT_NODE;
1143 dent_key_init_flash(c, &dent2->key, old_dir->i_ino, old_nm);
1146 dent2->inum = cpu_to_le64(whiteout->i_ino);
1147 dent2->type = get_dent_type(whiteout->i_mode);
1149 /* Make deletion dent */
1151 dent2->type = DT_UNKNOWN;
1153 dent2->nlen = cpu_to_le16(fname_len(old_nm));
1154 memcpy(dent2->name, fname_name(old_nm), fname_len(old_nm));
1155 dent2->name[fname_len(old_nm)] = '\0';
1156 set_dent_cookie(c, dent2);
1157 zero_dent_node_unused(dent2);
1158 ubifs_prep_grp_node(c, dent2, dlen2, 0);
1160 p = (void *)dent2 + aligned_dlen2;
1162 pack_inode(c, p, new_inode, 0);
1163 p += ALIGN(ilen, 8);
1167 pack_inode(c, p, old_dir, 1);
1169 pack_inode(c, p, old_dir, 0);
1170 p += ALIGN(plen, 8);
1171 pack_inode(c, p, new_dir, 1);
1174 if (last_reference) {
1175 err = ubifs_add_orphan(c, new_inode->i_ino);
1177 release_head(c, BASEHD);
1180 new_ui->del_cmtno = c->cmt_no;
1183 err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
1187 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1189 ubifs_wbuf_add_ino_nolock(wbuf, new_dir->i_ino);
1190 ubifs_wbuf_add_ino_nolock(wbuf, old_dir->i_ino);
1192 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
1195 release_head(c, BASEHD);
1197 dent_key_init(c, &key, new_dir->i_ino, new_nm);
1198 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, new_nm);
1202 offs += aligned_dlen1;
1204 dent_key_init(c, &key, old_dir->i_ino, old_nm);
1205 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, old_nm);
1209 ubifs_delete_orphan(c, whiteout->i_ino);
1211 err = ubifs_add_dirt(c, lnum, dlen2);
1215 dent_key_init(c, &key, old_dir->i_ino, old_nm);
1216 err = ubifs_tnc_remove_nm(c, &key, old_nm);
1221 offs += aligned_dlen2;
1223 ino_key_init(c, &key, new_inode->i_ino);
1224 err = ubifs_tnc_add(c, &key, lnum, offs, ilen);
1227 offs += ALIGN(ilen, 8);
1230 ino_key_init(c, &key, old_dir->i_ino);
1231 err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1236 offs += ALIGN(plen, 8);
1237 ino_key_init(c, &key, new_dir->i_ino);
1238 err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1243 finish_reservation(c);
1245 mark_inode_clean(c, new_ui);
1246 spin_lock(&new_ui->ui_lock);
1247 new_ui->synced_i_size = new_ui->ui_size;
1248 spin_unlock(&new_ui->ui_lock);
1250 mark_inode_clean(c, ubifs_inode(old_dir));
1252 mark_inode_clean(c, ubifs_inode(new_dir));
1257 release_head(c, BASEHD);
1259 ubifs_ro_mode(c, err);
1261 ubifs_delete_orphan(c, new_inode->i_ino);
1263 finish_reservation(c);
1270 * truncate_data_node - re-compress/encrypt a truncated data node.
1271 * @c: UBIFS file-system description object
1272 * @inode: inode which referes to the data node
1273 * @block: data block number
1274 * @dn: data node to re-compress
1275 * @new_len: new length
1277 * This function is used when an inode is truncated and the last data node of
1278 * the inode has to be re-compressed/encrypted and re-written.
1280 static int truncate_data_node(const struct ubifs_info *c, const struct inode *inode,
1281 unsigned int block, struct ubifs_data_node *dn,
1285 int err, compr_type;
1286 u32 dlen, out_len, old_dlen;
1288 out_len = le32_to_cpu(dn->size);
1289 buf = kmalloc_array(out_len, WORST_COMPR_FACTOR, GFP_NOFS);
1293 dlen = old_dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1294 compr_type = le16_to_cpu(dn->compr_type);
1296 if (ubifs_crypt_is_encrypted(inode)) {
1297 err = ubifs_decrypt(inode, dn, &dlen, block);
1302 if (compr_type == UBIFS_COMPR_NONE) {
1305 err = ubifs_decompress(c, &dn->data, dlen, buf, &out_len, compr_type);
1309 ubifs_compress(c, buf, *new_len, &dn->data, &out_len, &compr_type);
1312 if (ubifs_crypt_is_encrypted(inode)) {
1313 err = ubifs_encrypt(inode, dn, out_len, &old_dlen, block);
1322 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
1323 dn->compr_type = cpu_to_le16(compr_type);
1324 dn->size = cpu_to_le32(*new_len);
1325 *new_len = UBIFS_DATA_NODE_SZ + out_len;
1333 * ubifs_jnl_truncate - update the journal for a truncation.
1334 * @c: UBIFS file-system description object
1335 * @inode: inode to truncate
1336 * @old_size: old size
1337 * @new_size: new size
1339 * When the size of a file decreases due to truncation, a truncation node is
1340 * written, the journal tree is updated, and the last data block is re-written
1341 * if it has been affected. The inode is also updated in order to synchronize
1342 * the new inode size.
1344 * This function marks the inode as clean and returns zero on success. In case
1345 * of failure, a negative error code is returned.
1347 int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
1348 loff_t old_size, loff_t new_size)
1350 union ubifs_key key, to_key;
1351 struct ubifs_ino_node *ino;
1352 struct ubifs_trun_node *trun;
1353 struct ubifs_data_node *uninitialized_var(dn);
1354 int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
1355 struct ubifs_inode *ui = ubifs_inode(inode);
1356 ino_t inum = inode->i_ino;
1359 dbg_jnl("ino %lu, size %lld -> %lld",
1360 (unsigned long)inum, old_size, new_size);
1361 ubifs_assert(!ui->data_len);
1362 ubifs_assert(S_ISREG(inode->i_mode));
1363 ubifs_assert(mutex_is_locked(&ui->ui_mutex));
1365 sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
1366 UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
1367 ino = kmalloc(sz, GFP_NOFS);
1371 trun = (void *)ino + UBIFS_INO_NODE_SZ;
1372 trun->ch.node_type = UBIFS_TRUN_NODE;
1373 trun->inum = cpu_to_le32(inum);
1374 trun->old_size = cpu_to_le64(old_size);
1375 trun->new_size = cpu_to_le64(new_size);
1376 zero_trun_node_unused(trun);
1378 dlen = new_size & (UBIFS_BLOCK_SIZE - 1);
1380 /* Get last data block so it can be truncated */
1381 dn = (void *)trun + UBIFS_TRUN_NODE_SZ;
1382 blk = new_size >> UBIFS_BLOCK_SHIFT;
1383 data_key_init(c, &key, inum, blk);
1384 dbg_jnlk(&key, "last block key ");
1385 err = ubifs_tnc_lookup(c, &key, dn);
1387 dlen = 0; /* Not found (so it is a hole) */
1391 if (le32_to_cpu(dn->size) <= dlen)
1392 dlen = 0; /* Nothing to do */
1394 err = truncate_data_node(c, inode, blk, dn, &dlen);
1401 /* Must make reservation before allocating sequence numbers */
1402 len = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ;
1405 err = make_reservation(c, BASEHD, len);
1409 pack_inode(c, ino, inode, 0);
1410 ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
1412 ubifs_prep_grp_node(c, dn, dlen, 1);
1414 err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
1418 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
1419 release_head(c, BASEHD);
1422 sz = offs + UBIFS_INO_NODE_SZ + UBIFS_TRUN_NODE_SZ;
1423 err = ubifs_tnc_add(c, &key, lnum, sz, dlen);
1428 ino_key_init(c, &key, inum);
1429 err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ);
1433 err = ubifs_add_dirt(c, lnum, UBIFS_TRUN_NODE_SZ);
1437 bit = new_size & (UBIFS_BLOCK_SIZE - 1);
1438 blk = (new_size >> UBIFS_BLOCK_SHIFT) + (bit ? 1 : 0);
1439 data_key_init(c, &key, inum, blk);
1441 bit = old_size & (UBIFS_BLOCK_SIZE - 1);
1442 blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0 : 1);
1443 data_key_init(c, &to_key, inum, blk);
1445 err = ubifs_tnc_remove_range(c, &key, &to_key);
1449 finish_reservation(c);
1450 spin_lock(&ui->ui_lock);
1451 ui->synced_i_size = ui->ui_size;
1452 spin_unlock(&ui->ui_lock);
1453 mark_inode_clean(c, ui);
1458 release_head(c, BASEHD);
1460 ubifs_ro_mode(c, err);
1461 finish_reservation(c);
1469 * ubifs_jnl_delete_xattr - delete an extended attribute.
1470 * @c: UBIFS file-system description object
1472 * @inode: extended attribute inode
1473 * @nm: extended attribute entry name
1475 * This function delete an extended attribute which is very similar to
1476 * un-linking regular files - it writes a deletion xentry, a deletion inode and
1477 * updates the target inode. Returns zero in case of success and a negative
1478 * error code in case of failure.
1480 int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
1481 const struct inode *inode,
1482 const struct fscrypt_name *nm)
1484 int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen;
1485 struct ubifs_dent_node *xent;
1486 struct ubifs_ino_node *ino;
1487 union ubifs_key xent_key, key1, key2;
1488 int sync = IS_DIRSYNC(host);
1489 struct ubifs_inode *host_ui = ubifs_inode(host);
1491 ubifs_assert(inode->i_nlink == 0);
1492 ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
1495 * Since we are deleting the inode, we do not bother to attach any data
1496 * to it and assume its length is %UBIFS_INO_NODE_SZ.
1498 xlen = UBIFS_DENT_NODE_SZ + fname_len(nm) + 1;
1499 aligned_xlen = ALIGN(xlen, 8);
1500 hlen = host_ui->data_len + UBIFS_INO_NODE_SZ;
1501 len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
1503 xent = kzalloc(len, GFP_NOFS);
1507 /* Make reservation before allocating sequence numbers */
1508 err = make_reservation(c, BASEHD, len);
1514 xent->ch.node_type = UBIFS_XENT_NODE;
1515 xent_key_init(c, &xent_key, host->i_ino, nm);
1516 key_write(c, &xent_key, xent->key);
1518 xent->type = get_dent_type(inode->i_mode);
1519 xent->nlen = cpu_to_le16(fname_len(nm));
1520 memcpy(xent->name, fname_name(nm), fname_len(nm));
1521 xent->name[fname_len(nm)] = '\0';
1522 zero_dent_node_unused(xent);
1523 ubifs_prep_grp_node(c, xent, xlen, 0);
1525 ino = (void *)xent + aligned_xlen;
1526 pack_inode(c, ino, inode, 0);
1527 ino = (void *)ino + UBIFS_INO_NODE_SZ;
1528 pack_inode(c, ino, host, 1);
1530 err = write_head(c, BASEHD, xent, len, &lnum, &xent_offs, sync);
1532 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
1533 release_head(c, BASEHD);
1538 /* Remove the extended attribute entry from TNC */
1539 err = ubifs_tnc_remove_nm(c, &xent_key, nm);
1542 err = ubifs_add_dirt(c, lnum, xlen);
1547 * Remove all nodes belonging to the extended attribute inode from TNC.
1548 * Well, there actually must be only one node - the inode itself.
1550 lowest_ino_key(c, &key1, inode->i_ino);
1551 highest_ino_key(c, &key2, inode->i_ino);
1552 err = ubifs_tnc_remove_range(c, &key1, &key2);
1555 err = ubifs_add_dirt(c, lnum, UBIFS_INO_NODE_SZ);
1559 /* And update TNC with the new host inode position */
1560 ino_key_init(c, &key1, host->i_ino);
1561 err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen);
1565 finish_reservation(c);
1566 spin_lock(&host_ui->ui_lock);
1567 host_ui->synced_i_size = host_ui->ui_size;
1568 spin_unlock(&host_ui->ui_lock);
1569 mark_inode_clean(c, host_ui);
1573 ubifs_ro_mode(c, err);
1574 finish_reservation(c);
1579 * ubifs_jnl_change_xattr - change an extended attribute.
1580 * @c: UBIFS file-system description object
1581 * @inode: extended attribute inode
1584 * This function writes the updated version of an extended attribute inode and
1585 * the host inode to the journal (to the base head). The host inode is written
1586 * after the extended attribute inode in order to guarantee that the extended
1587 * attribute will be flushed when the inode is synchronized by 'fsync()' and
1588 * consequently, the write-buffer is synchronized. This function returns zero
1589 * in case of success and a negative error code in case of failure.
1591 int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
1592 const struct inode *host)
1594 int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
1595 struct ubifs_inode *host_ui = ubifs_inode(host);
1596 struct ubifs_ino_node *ino;
1597 union ubifs_key key;
1598 int sync = IS_DIRSYNC(host);
1600 dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1601 ubifs_assert(host->i_nlink > 0);
1602 ubifs_assert(inode->i_nlink > 0);
1603 ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
1605 len1 = UBIFS_INO_NODE_SZ + host_ui->data_len;
1606 len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode)->data_len;
1607 aligned_len1 = ALIGN(len1, 8);
1608 aligned_len = aligned_len1 + ALIGN(len2, 8);
1610 ino = kzalloc(aligned_len, GFP_NOFS);
1614 /* Make reservation before allocating sequence numbers */
1615 err = make_reservation(c, BASEHD, aligned_len);
1619 pack_inode(c, ino, host, 0);
1620 pack_inode(c, (void *)ino + aligned_len1, inode, 1);
1622 err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
1623 if (!sync && !err) {
1624 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1626 ubifs_wbuf_add_ino_nolock(wbuf, host->i_ino);
1627 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
1629 release_head(c, BASEHD);
1633 ino_key_init(c, &key, host->i_ino);
1634 err = ubifs_tnc_add(c, &key, lnum, offs, len1);
1638 ino_key_init(c, &key, inode->i_ino);
1639 err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2);
1643 finish_reservation(c);
1644 spin_lock(&host_ui->ui_lock);
1645 host_ui->synced_i_size = host_ui->ui_size;
1646 spin_unlock(&host_ui->ui_lock);
1647 mark_inode_clean(c, host_ui);
1652 ubifs_ro_mode(c, err);
1653 finish_reservation(c);