1 /*
2  * This file is part of UBIFS.
3  *
4  * Copyright (C) 2006-2008 Nokia Corporation.
5  *
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.
9  *
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
13  * more details.
14  *
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
18  *
19  * Authors: Artem Bityutskiy (Битюцкий Артём)
20  *          Adrian Hunter
21  */
22 
23 /*
24  * This file implements UBIFS journal.
25  *
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.
35  *
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.
40  *
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
43  * only data nodes.
44  *
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
49  * journal.
50  *
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).
54  *
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
58  * all the nodes.
59  */
60 
61 #include "ubifs.h"
62 
63 /**
64  * zero_ino_node_unused - zero out unused fields of an on-flash inode node.
65  * @ino: the inode to zero out
66  */
zero_ino_node_unused(struct ubifs_ino_node * ino)67 static inline void zero_ino_node_unused(struct ubifs_ino_node *ino)
68 {
69 	memset(ino->padding1, 0, 4);
70 	memset(ino->padding2, 0, 26);
71 }
72 
73 /**
74  * zero_dent_node_unused - zero out unused fields of an on-flash directory
75  *                         entry node.
76  * @dent: the directory entry to zero out
77  */
zero_dent_node_unused(struct ubifs_dent_node * dent)78 static inline void zero_dent_node_unused(struct ubifs_dent_node *dent)
79 {
80 	dent->padding1 = 0;
81 	memset(dent->padding2, 0, 4);
82 }
83 
84 /**
85  * zero_data_node_unused - zero out unused fields of an on-flash data node.
86  * @data: the data node to zero out
87  */
zero_data_node_unused(struct ubifs_data_node * data)88 static inline void zero_data_node_unused(struct ubifs_data_node *data)
89 {
90 	memset(data->padding, 0, 2);
91 }
92 
93 /**
94  * zero_trun_node_unused - zero out unused fields of an on-flash truncation
95  *                         node.
96  * @trun: the truncation node to zero out
97  */
zero_trun_node_unused(struct ubifs_trun_node * trun)98 static inline void zero_trun_node_unused(struct ubifs_trun_node *trun)
99 {
100 	memset(trun->padding, 0, 12);
101 }
102 
103 /**
104  * reserve_space - reserve space in the journal.
105  * @c: UBIFS file-system description object
106  * @jhead: journal head number
107  * @len: node length
108  *
109  * This function reserves space in journal head @head. If the reservation
110  * succeeded, the journal head stays locked and later has to be unlocked using
111  * 'release_head()'. 'write_node()' and 'write_head()' functions also unlock
112  * it. Returns zero in case of success, %-EAGAIN if commit has to be done, and
113  * other negative error codes in case of other failures.
114  */
reserve_space(struct ubifs_info * c,int jhead,int len)115 static int reserve_space(struct ubifs_info *c, int jhead, int len)
116 {
117 	int err = 0, err1, retries = 0, avail, lnum, offs, squeeze;
118 	struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
119 
120 	/*
121 	 * Typically, the base head has smaller nodes written to it, so it is
122 	 * better to try to allocate space at the ends of eraseblocks. This is
123 	 * what the squeeze parameter does.
124 	 */
125 	ubifs_assert(!c->ro_media && !c->ro_mount);
126 	squeeze = (jhead == BASEHD);
127 again:
128 	mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
129 
130 	if (c->ro_error) {
131 		err = -EROFS;
132 		goto out_unlock;
133 	}
134 
135 	avail = c->leb_size - wbuf->offs - wbuf->used;
136 	if (wbuf->lnum != -1 && avail >= len)
137 		return 0;
138 
139 	/*
140 	 * Write buffer wasn't seek'ed or there is no enough space - look for an
141 	 * LEB with some empty space.
142 	 */
143 	lnum = ubifs_find_free_space(c, len, &offs, squeeze);
144 	if (lnum >= 0)
145 		goto out;
146 
147 	err = lnum;
148 	if (err != -ENOSPC)
149 		goto out_unlock;
150 
151 	/*
152 	 * No free space, we have to run garbage collector to make
153 	 * some. But the write-buffer mutex has to be unlocked because
154 	 * GC also takes it.
155 	 */
156 	dbg_jnl("no free space in jhead %s, run GC", dbg_jhead(jhead));
157 	mutex_unlock(&wbuf->io_mutex);
158 
159 	lnum = ubifs_garbage_collect(c, 0);
160 	if (lnum < 0) {
161 		err = lnum;
162 		if (err != -ENOSPC)
163 			return err;
164 
165 		/*
166 		 * GC could not make a free LEB. But someone else may
167 		 * have allocated new bud for this journal head,
168 		 * because we dropped @wbuf->io_mutex, so try once
169 		 * again.
170 		 */
171 		dbg_jnl("GC couldn't make a free LEB for jhead %s",
172 			dbg_jhead(jhead));
173 		if (retries++ < 2) {
174 			dbg_jnl("retry (%d)", retries);
175 			goto again;
176 		}
177 
178 		dbg_jnl("return -ENOSPC");
179 		return err;
180 	}
181 
182 	mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
183 	dbg_jnl("got LEB %d for jhead %s", lnum, dbg_jhead(jhead));
184 	avail = c->leb_size - wbuf->offs - wbuf->used;
185 
186 	if (wbuf->lnum != -1 && avail >= len) {
187 		/*
188 		 * Someone else has switched the journal head and we have
189 		 * enough space now. This happens when more than one process is
190 		 * trying to write to the same journal head at the same time.
191 		 */
192 		dbg_jnl("return LEB %d back, already have LEB %d:%d",
193 			lnum, wbuf->lnum, wbuf->offs + wbuf->used);
194 		err = ubifs_return_leb(c, lnum);
195 		if (err)
196 			goto out_unlock;
197 		return 0;
198 	}
199 
200 	offs = 0;
201 
202 out:
203 	/*
204 	 * Make sure we synchronize the write-buffer before we add the new bud
205 	 * to the log. Otherwise we may have a power cut after the log
206 	 * reference node for the last bud (@lnum) is written but before the
207 	 * write-buffer data are written to the next-to-last bud
208 	 * (@wbuf->lnum). And the effect would be that the recovery would see
209 	 * that there is corruption in the next-to-last bud.
210 	 */
211 	err = ubifs_wbuf_sync_nolock(wbuf);
212 	if (err)
213 		goto out_return;
214 	err = ubifs_add_bud_to_log(c, jhead, lnum, offs);
215 	if (err)
216 		goto out_return;
217 	err = ubifs_wbuf_seek_nolock(wbuf, lnum, offs, wbuf->dtype);
218 	if (err)
219 		goto out_unlock;
220 
221 	return 0;
222 
223 out_unlock:
224 	mutex_unlock(&wbuf->io_mutex);
225 	return err;
226 
227 out_return:
228 	/* An error occurred and the LEB has to be returned to lprops */
229 	ubifs_assert(err < 0);
230 	err1 = ubifs_return_leb(c, lnum);
231 	if (err1 && err == -EAGAIN)
232 		/*
233 		 * Return original error code only if it is not %-EAGAIN,
234 		 * which is not really an error. Otherwise, return the error
235 		 * code of 'ubifs_return_leb()'.
236 		 */
237 		err = err1;
238 	mutex_unlock(&wbuf->io_mutex);
239 	return err;
240 }
241 
242 /**
243  * write_node - write node to a journal head.
244  * @c: UBIFS file-system description object
245  * @jhead: journal head
246  * @node: node to write
247  * @len: node length
248  * @lnum: LEB number written is returned here
249  * @offs: offset written is returned here
250  *
251  * This function writes a node to reserved space of journal head @jhead.
252  * Returns zero in case of success and a negative error code in case of
253  * failure.
254  */
write_node(struct ubifs_info * c,int jhead,void * node,int len,int * lnum,int * offs)255 static int write_node(struct ubifs_info *c, int jhead, void *node, int len,
256 		      int *lnum, int *offs)
257 {
258 	struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
259 
260 	ubifs_assert(jhead != GCHD);
261 
262 	*lnum = c->jheads[jhead].wbuf.lnum;
263 	*offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
264 
265 	dbg_jnl("jhead %s, LEB %d:%d, len %d",
266 		dbg_jhead(jhead), *lnum, *offs, len);
267 	ubifs_prepare_node(c, node, len, 0);
268 
269 	return ubifs_wbuf_write_nolock(wbuf, node, len);
270 }
271 
272 /**
273  * write_head - write data to a journal head.
274  * @c: UBIFS file-system description object
275  * @jhead: journal head
276  * @buf: buffer to write
277  * @len: length to write
278  * @lnum: LEB number written is returned here
279  * @offs: offset written is returned here
280  * @sync: non-zero if the write-buffer has to by synchronized
281  *
282  * This function is the same as 'write_node()' but it does not assume the
283  * buffer it is writing is a node, so it does not prepare it (which means
284  * initializing common header and calculating CRC).
285  */
write_head(struct ubifs_info * c,int jhead,void * buf,int len,int * lnum,int * offs,int sync)286 static int write_head(struct ubifs_info *c, int jhead, void *buf, int len,
287 		      int *lnum, int *offs, int sync)
288 {
289 	int err;
290 	struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
291 
292 	ubifs_assert(jhead != GCHD);
293 
294 	*lnum = c->jheads[jhead].wbuf.lnum;
295 	*offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
296 	dbg_jnl("jhead %s, LEB %d:%d, len %d",
297 		dbg_jhead(jhead), *lnum, *offs, len);
298 
299 	err = ubifs_wbuf_write_nolock(wbuf, buf, len);
300 	if (err)
301 		return err;
302 	if (sync)
303 		err = ubifs_wbuf_sync_nolock(wbuf);
304 	return err;
305 }
306 
307 /**
308  * make_reservation - reserve journal space.
309  * @c: UBIFS file-system description object
310  * @jhead: journal head
311  * @len: how many bytes to reserve
312  *
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
317  * failure.
318  *
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
321  * TNC.
322  */
make_reservation(struct ubifs_info * c,int jhead,int len)323 static int make_reservation(struct ubifs_info *c, int jhead, int len)
324 {
325 	int err, cmt_retries = 0, nospc_retries = 0;
326 
327 again:
328 	down_read(&c->commit_sem);
329 	err = reserve_space(c, jhead, len);
330 	if (!err)
331 		return 0;
332 	up_read(&c->commit_sem);
333 
334 	if (err == -ENOSPC) {
335 		/*
336 		 * GC could not make any progress. We should try to commit
337 		 * once because it could make some dirty space and GC would
338 		 * make progress, so make the error -EAGAIN so that the below
339 		 * will commit and re-try.
340 		 */
341 		if (nospc_retries++ < 2) {
342 			dbg_jnl("no space, retry");
343 			err = -EAGAIN;
344 		}
345 
346 		/*
347 		 * This means that the budgeting is incorrect. We always have
348 		 * to be able to write to the media, because all operations are
349 		 * budgeted. Deletions are not budgeted, though, but we reserve
350 		 * an extra LEB for them.
351 		 */
352 	}
353 
354 	if (err != -EAGAIN)
355 		goto out;
356 
357 	/*
358 	 * -EAGAIN means that the journal is full or too large, or the above
359 	 * code wants to do one commit. Do this and re-try.
360 	 */
361 	if (cmt_retries > 128) {
362 		/*
363 		 * This should not happen unless the journal size limitations
364 		 * are too tough.
365 		 */
366 		ubifs_err("stuck in space allocation");
367 		err = -ENOSPC;
368 		goto out;
369 	} else if (cmt_retries > 32)
370 		ubifs_warn("too many space allocation re-tries (%d)",
371 			   cmt_retries);
372 
373 	dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
374 		cmt_retries);
375 	cmt_retries += 1;
376 
377 	err = ubifs_run_commit(c);
378 	if (err)
379 		return err;
380 	goto again;
381 
382 out:
383 	ubifs_err("cannot reserve %d bytes in jhead %d, error %d",
384 		  len, jhead, err);
385 	if (err == -ENOSPC) {
386 		/* This are some budgeting problems, print useful information */
387 		down_write(&c->commit_sem);
388 		dbg_dump_stack();
389 		dbg_dump_budg(c, &c->bi);
390 		dbg_dump_lprops(c);
391 		cmt_retries = dbg_check_lprops(c);
392 		up_write(&c->commit_sem);
393 	}
394 	return err;
395 }
396 
397 /**
398  * release_head - release a journal head.
399  * @c: UBIFS file-system description object
400  * @jhead: journal head
401  *
402  * This function releases journal head @jhead which was locked by
403  * the 'make_reservation()' function. It has to be called after each successful
404  * 'make_reservation()' invocation.
405  */
release_head(struct ubifs_info * c,int jhead)406 static inline void release_head(struct ubifs_info *c, int jhead)
407 {
408 	mutex_unlock(&c->jheads[jhead].wbuf.io_mutex);
409 }
410 
411 /**
412  * finish_reservation - finish a reservation.
413  * @c: UBIFS file-system description object
414  *
415  * This function finishes journal space reservation. It must be called after
416  * 'make_reservation()'.
417  */
finish_reservation(struct ubifs_info * c)418 static void finish_reservation(struct ubifs_info *c)
419 {
420 	up_read(&c->commit_sem);
421 }
422 
423 /**
424  * get_dent_type - translate VFS inode mode to UBIFS directory entry type.
425  * @mode: inode mode
426  */
get_dent_type(int mode)427 static int get_dent_type(int mode)
428 {
429 	switch (mode & S_IFMT) {
430 	case S_IFREG:
431 		return UBIFS_ITYPE_REG;
432 	case S_IFDIR:
433 		return UBIFS_ITYPE_DIR;
434 	case S_IFLNK:
435 		return UBIFS_ITYPE_LNK;
436 	case S_IFBLK:
437 		return UBIFS_ITYPE_BLK;
438 	case S_IFCHR:
439 		return UBIFS_ITYPE_CHR;
440 	case S_IFIFO:
441 		return UBIFS_ITYPE_FIFO;
442 	case S_IFSOCK:
443 		return UBIFS_ITYPE_SOCK;
444 	default:
445 		BUG();
446 	}
447 	return 0;
448 }
449 
450 /**
451  * pack_inode - pack an inode node.
452  * @c: UBIFS file-system description object
453  * @ino: buffer in which to pack inode node
454  * @inode: inode to pack
455  * @last: indicates the last node of the group
456  */
pack_inode(struct ubifs_info * c,struct ubifs_ino_node * ino,const struct inode * inode,int last)457 static void pack_inode(struct ubifs_info *c, struct ubifs_ino_node *ino,
458 		       const struct inode *inode, int last)
459 {
460 	int data_len = 0, last_reference = !inode->i_nlink;
461 	struct ubifs_inode *ui = ubifs_inode(inode);
462 
463 	ino->ch.node_type = UBIFS_INO_NODE;
464 	ino_key_init_flash(c, &ino->key, inode->i_ino);
465 	ino->creat_sqnum = cpu_to_le64(ui->creat_sqnum);
466 	ino->atime_sec  = cpu_to_le64(inode->i_atime.tv_sec);
467 	ino->atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
468 	ino->ctime_sec  = cpu_to_le64(inode->i_ctime.tv_sec);
469 	ino->ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
470 	ino->mtime_sec  = cpu_to_le64(inode->i_mtime.tv_sec);
471 	ino->mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
472 	ino->uid   = cpu_to_le32(inode->i_uid);
473 	ino->gid   = cpu_to_le32(inode->i_gid);
474 	ino->mode  = cpu_to_le32(inode->i_mode);
475 	ino->flags = cpu_to_le32(ui->flags);
476 	ino->size  = cpu_to_le64(ui->ui_size);
477 	ino->nlink = cpu_to_le32(inode->i_nlink);
478 	ino->compr_type  = cpu_to_le16(ui->compr_type);
479 	ino->data_len    = cpu_to_le32(ui->data_len);
480 	ino->xattr_cnt   = cpu_to_le32(ui->xattr_cnt);
481 	ino->xattr_size  = cpu_to_le32(ui->xattr_size);
482 	ino->xattr_names = cpu_to_le32(ui->xattr_names);
483 	zero_ino_node_unused(ino);
484 
485 	/*
486 	 * Drop the attached data if this is a deletion inode, the data is not
487 	 * needed anymore.
488 	 */
489 	if (!last_reference) {
490 		memcpy(ino->data, ui->data, ui->data_len);
491 		data_len = ui->data_len;
492 	}
493 
494 	ubifs_prep_grp_node(c, ino, UBIFS_INO_NODE_SZ + data_len, last);
495 }
496 
497 /**
498  * mark_inode_clean - mark UBIFS inode as clean.
499  * @c: UBIFS file-system description object
500  * @ui: UBIFS inode to mark as clean
501  *
502  * This helper function marks UBIFS inode @ui as clean by cleaning the
503  * @ui->dirty flag and releasing its budget. Note, VFS may still treat the
504  * inode as dirty and try to write it back, but 'ubifs_write_inode()' would
505  * just do nothing.
506  */
mark_inode_clean(struct ubifs_info * c,struct ubifs_inode * ui)507 static void mark_inode_clean(struct ubifs_info *c, struct ubifs_inode *ui)
508 {
509 	if (ui->dirty)
510 		ubifs_release_dirty_inode_budget(c, ui);
511 	ui->dirty = 0;
512 }
513 
514 /**
515  * ubifs_jnl_update - update inode.
516  * @c: UBIFS file-system description object
517  * @dir: parent inode or host inode in case of extended attributes
518  * @nm: directory entry name
519  * @inode: inode to update
520  * @deletion: indicates a directory entry deletion i.e unlink or rmdir
521  * @xent: non-zero if the directory entry is an extended attribute entry
522  *
523  * This function updates an inode by writing a directory entry (or extended
524  * attribute entry), the inode itself, and the parent directory inode (or the
525  * host inode) to the journal.
526  *
527  * The function writes the host inode @dir last, which is important in case of
528  * extended attributes. Indeed, then we guarantee that if the host inode gets
529  * synchronized (with 'fsync()'), and the write-buffer it sits in gets flushed,
530  * the extended attribute inode gets flushed too. And this is exactly what the
531  * user expects - synchronizing the host inode synchronizes its extended
532  * attributes. Similarly, this guarantees that if @dir is synchronized, its
533  * directory entry corresponding to @nm gets synchronized too.
534  *
535  * If the inode (@inode) or the parent directory (@dir) are synchronous, this
536  * function synchronizes the write-buffer.
537  *
538  * This function marks the @dir and @inode inodes as clean and returns zero on
539  * success. In case of failure, a negative error code is returned.
540  */
ubifs_jnl_update(struct ubifs_info * c,const struct inode * dir,const struct qstr * nm,const struct inode * inode,int deletion,int xent)541 int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,
542 		     const struct qstr *nm, const struct inode *inode,
543 		     int deletion, int xent)
544 {
545 	int err, dlen, ilen, len, lnum, ino_offs, dent_offs;
546 	int aligned_dlen, aligned_ilen, sync = IS_DIRSYNC(dir);
547 	int last_reference = !!(deletion && inode->i_nlink == 0);
548 	struct ubifs_inode *ui = ubifs_inode(inode);
549 	struct ubifs_inode *dir_ui = ubifs_inode(dir);
550 	struct ubifs_dent_node *dent;
551 	struct ubifs_ino_node *ino;
552 	union ubifs_key dent_key, ino_key;
553 
554 	dbg_jnl("ino %lu, dent '%.*s', data len %d in dir ino %lu",
555 		inode->i_ino, nm->len, nm->name, ui->data_len, dir->i_ino);
556 	ubifs_assert(dir_ui->data_len == 0);
557 	ubifs_assert(mutex_is_locked(&dir_ui->ui_mutex));
558 
559 	dlen = UBIFS_DENT_NODE_SZ + nm->len + 1;
560 	ilen = UBIFS_INO_NODE_SZ;
561 
562 	/*
563 	 * If the last reference to the inode is being deleted, then there is
564 	 * no need to attach and write inode data, it is being deleted anyway.
565 	 * And if the inode is being deleted, no need to synchronize
566 	 * write-buffer even if the inode is synchronous.
567 	 */
568 	if (!last_reference) {
569 		ilen += ui->data_len;
570 		sync |= IS_SYNC(inode);
571 	}
572 
573 	aligned_dlen = ALIGN(dlen, 8);
574 	aligned_ilen = ALIGN(ilen, 8);
575 	len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
576 	dent = kmalloc(len, GFP_NOFS);
577 	if (!dent)
578 		return -ENOMEM;
579 
580 	/* Make reservation before allocating sequence numbers */
581 	err = make_reservation(c, BASEHD, len);
582 	if (err)
583 		goto out_free;
584 
585 	if (!xent) {
586 		dent->ch.node_type = UBIFS_DENT_NODE;
587 		dent_key_init(c, &dent_key, dir->i_ino, nm);
588 	} else {
589 		dent->ch.node_type = UBIFS_XENT_NODE;
590 		xent_key_init(c, &dent_key, dir->i_ino, nm);
591 	}
592 
593 	key_write(c, &dent_key, dent->key);
594 	dent->inum = deletion ? 0 : cpu_to_le64(inode->i_ino);
595 	dent->type = get_dent_type(inode->i_mode);
596 	dent->nlen = cpu_to_le16(nm->len);
597 	memcpy(dent->name, nm->name, nm->len);
598 	dent->name[nm->len] = '\0';
599 	zero_dent_node_unused(dent);
600 	ubifs_prep_grp_node(c, dent, dlen, 0);
601 
602 	ino = (void *)dent + aligned_dlen;
603 	pack_inode(c, ino, inode, 0);
604 	ino = (void *)ino + aligned_ilen;
605 	pack_inode(c, ino, dir, 1);
606 
607 	if (last_reference) {
608 		err = ubifs_add_orphan(c, inode->i_ino);
609 		if (err) {
610 			release_head(c, BASEHD);
611 			goto out_finish;
612 		}
613 		ui->del_cmtno = c->cmt_no;
614 	}
615 
616 	err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
617 	if (err)
618 		goto out_release;
619 	if (!sync) {
620 		struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
621 
622 		ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
623 		ubifs_wbuf_add_ino_nolock(wbuf, dir->i_ino);
624 	}
625 	release_head(c, BASEHD);
626 	kfree(dent);
627 
628 	if (deletion) {
629 		err = ubifs_tnc_remove_nm(c, &dent_key, nm);
630 		if (err)
631 			goto out_ro;
632 		err = ubifs_add_dirt(c, lnum, dlen);
633 	} else
634 		err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen, nm);
635 	if (err)
636 		goto out_ro;
637 
638 	/*
639 	 * Note, we do not remove the inode from TNC even if the last reference
640 	 * to it has just been deleted, because the inode may still be opened.
641 	 * Instead, the inode has been added to orphan lists and the orphan
642 	 * subsystem will take further care about it.
643 	 */
644 	ino_key_init(c, &ino_key, inode->i_ino);
645 	ino_offs = dent_offs + aligned_dlen;
646 	err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen);
647 	if (err)
648 		goto out_ro;
649 
650 	ino_key_init(c, &ino_key, dir->i_ino);
651 	ino_offs += aligned_ilen;
652 	err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, UBIFS_INO_NODE_SZ);
653 	if (err)
654 		goto out_ro;
655 
656 	finish_reservation(c);
657 	spin_lock(&ui->ui_lock);
658 	ui->synced_i_size = ui->ui_size;
659 	spin_unlock(&ui->ui_lock);
660 	mark_inode_clean(c, ui);
661 	mark_inode_clean(c, dir_ui);
662 	return 0;
663 
664 out_finish:
665 	finish_reservation(c);
666 out_free:
667 	kfree(dent);
668 	return err;
669 
670 out_release:
671 	release_head(c, BASEHD);
672 	kfree(dent);
673 out_ro:
674 	ubifs_ro_mode(c, err);
675 	if (last_reference)
676 		ubifs_delete_orphan(c, inode->i_ino);
677 	finish_reservation(c);
678 	return err;
679 }
680 
681 /**
682  * ubifs_jnl_write_data - write a data node to the journal.
683  * @c: UBIFS file-system description object
684  * @inode: inode the data node belongs to
685  * @key: node key
686  * @buf: buffer to write
687  * @len: data length (must not exceed %UBIFS_BLOCK_SIZE)
688  *
689  * This function writes a data node to the journal. Returns %0 if the data node
690  * was successfully written, and a negative error code in case of failure.
691  */
ubifs_jnl_write_data(struct ubifs_info * c,const struct inode * inode,const union ubifs_key * key,const void * buf,int len)692 int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
693 			 const union ubifs_key *key, const void *buf, int len)
694 {
695 	struct ubifs_data_node *data;
696 	int err, lnum, offs, compr_type, out_len;
697 	int dlen = COMPRESSED_DATA_NODE_BUF_SZ, allocated = 1;
698 	struct ubifs_inode *ui = ubifs_inode(inode);
699 
700 	dbg_jnlk(key, "ino %lu, blk %u, len %d, key ",
701 		(unsigned long)key_inum(c, key), key_block(c, key), len);
702 	ubifs_assert(len <= UBIFS_BLOCK_SIZE);
703 
704 	data = kmalloc(dlen, GFP_NOFS | __GFP_NOWARN);
705 	if (!data) {
706 		/*
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.
712 		 */
713 		allocated = 0;
714 		mutex_lock(&c->write_reserve_mutex);
715 		data = c->write_reserve_buf;
716 	}
717 
718 	data->ch.node_type = UBIFS_DATA_NODE;
719 	key_write(c, key, &data->key);
720 	data->size = cpu_to_le32(len);
721 	zero_data_node_unused(data);
722 
723 	if (!(ui->flags & UBIFS_COMPR_FL))
724 		/* Compression is disabled for this inode */
725 		compr_type = UBIFS_COMPR_NONE;
726 	else
727 		compr_type = ui->compr_type;
728 
729 	out_len = dlen - UBIFS_DATA_NODE_SZ;
730 	ubifs_compress(buf, len, &data->data, &out_len, &compr_type);
731 	ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
732 
733 	dlen = UBIFS_DATA_NODE_SZ + out_len;
734 	data->compr_type = cpu_to_le16(compr_type);
735 
736 	/* Make reservation before allocating sequence numbers */
737 	err = make_reservation(c, DATAHD, dlen);
738 	if (err)
739 		goto out_free;
740 
741 	err = write_node(c, DATAHD, data, dlen, &lnum, &offs);
742 	if (err)
743 		goto out_release;
744 	ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf, key_inum(c, key));
745 	release_head(c, DATAHD);
746 
747 	err = ubifs_tnc_add(c, key, lnum, offs, dlen);
748 	if (err)
749 		goto out_ro;
750 
751 	finish_reservation(c);
752 	if (!allocated)
753 		mutex_unlock(&c->write_reserve_mutex);
754 	else
755 		kfree(data);
756 	return 0;
757 
758 out_release:
759 	release_head(c, DATAHD);
760 out_ro:
761 	ubifs_ro_mode(c, err);
762 	finish_reservation(c);
763 out_free:
764 	if (!allocated)
765 		mutex_unlock(&c->write_reserve_mutex);
766 	else
767 		kfree(data);
768 	return err;
769 }
770 
771 /**
772  * ubifs_jnl_write_inode - flush inode to the journal.
773  * @c: UBIFS file-system description object
774  * @inode: inode to flush
775  *
776  * This function writes inode @inode to the journal. If the inode is
777  * synchronous, it also synchronizes the write-buffer. Returns zero in case of
778  * success and a negative error code in case of failure.
779  */
ubifs_jnl_write_inode(struct ubifs_info * c,const struct inode * inode)780 int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode)
781 {
782 	int err, lnum, offs;
783 	struct ubifs_ino_node *ino;
784 	struct ubifs_inode *ui = ubifs_inode(inode);
785 	int sync = 0, len = UBIFS_INO_NODE_SZ, last_reference = !inode->i_nlink;
786 
787 	dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
788 
789 	/*
790 	 * If the inode is being deleted, do not write the attached data. No
791 	 * need to synchronize the write-buffer either.
792 	 */
793 	if (!last_reference) {
794 		len += ui->data_len;
795 		sync = IS_SYNC(inode);
796 	}
797 	ino = kmalloc(len, GFP_NOFS);
798 	if (!ino)
799 		return -ENOMEM;
800 
801 	/* Make reservation before allocating sequence numbers */
802 	err = make_reservation(c, BASEHD, len);
803 	if (err)
804 		goto out_free;
805 
806 	pack_inode(c, ino, inode, 1);
807 	err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
808 	if (err)
809 		goto out_release;
810 	if (!sync)
811 		ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
812 					  inode->i_ino);
813 	release_head(c, BASEHD);
814 
815 	if (last_reference) {
816 		err = ubifs_tnc_remove_ino(c, inode->i_ino);
817 		if (err)
818 			goto out_ro;
819 		ubifs_delete_orphan(c, inode->i_ino);
820 		err = ubifs_add_dirt(c, lnum, len);
821 	} else {
822 		union ubifs_key key;
823 
824 		ino_key_init(c, &key, inode->i_ino);
825 		err = ubifs_tnc_add(c, &key, lnum, offs, len);
826 	}
827 	if (err)
828 		goto out_ro;
829 
830 	finish_reservation(c);
831 	spin_lock(&ui->ui_lock);
832 	ui->synced_i_size = ui->ui_size;
833 	spin_unlock(&ui->ui_lock);
834 	kfree(ino);
835 	return 0;
836 
837 out_release:
838 	release_head(c, BASEHD);
839 out_ro:
840 	ubifs_ro_mode(c, err);
841 	finish_reservation(c);
842 out_free:
843 	kfree(ino);
844 	return err;
845 }
846 
847 /**
848  * ubifs_jnl_delete_inode - delete an inode.
849  * @c: UBIFS file-system description object
850  * @inode: inode to delete
851  *
852  * This function deletes inode @inode which includes removing it from orphans,
853  * deleting it from TNC and, in some cases, writing a deletion inode to the
854  * journal.
855  *
856  * When regular file inodes are unlinked or a directory inode is removed, the
857  * 'ubifs_jnl_update()' function writes a corresponding deletion inode and
858  * direntry to the media, and adds the inode to orphans. After this, when the
859  * last reference to this inode has been dropped, this function is called. In
860  * general, it has to write one more deletion inode to the media, because if
861  * a commit happened between 'ubifs_jnl_update()' and
862  * 'ubifs_jnl_delete_inode()', the deletion inode is not in the journal
863  * anymore, and in fact it might not be on the flash anymore, because it might
864  * have been garbage-collected already. And for optimization reasons UBIFS does
865  * not read the orphan area if it has been unmounted cleanly, so it would have
866  * no indication in the journal that there is a deleted inode which has to be
867  * removed from TNC.
868  *
869  * However, if there was no commit between 'ubifs_jnl_update()' and
870  * 'ubifs_jnl_delete_inode()', then there is no need to write the deletion
871  * inode to the media for the second time. And this is quite a typical case.
872  *
873  * This function returns zero in case of success and a negative error code in
874  * case of failure.
875  */
ubifs_jnl_delete_inode(struct ubifs_info * c,const struct inode * inode)876 int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode)
877 {
878 	int err;
879 	struct ubifs_inode *ui = ubifs_inode(inode);
880 
881 	ubifs_assert(inode->i_nlink == 0);
882 
883 	if (ui->del_cmtno != c->cmt_no)
884 		/* A commit happened for sure */
885 		return ubifs_jnl_write_inode(c, inode);
886 
887 	down_read(&c->commit_sem);
888 	/*
889 	 * Check commit number again, because the first test has been done
890 	 * without @c->commit_sem, so a commit might have happened.
891 	 */
892 	if (ui->del_cmtno != c->cmt_no) {
893 		up_read(&c->commit_sem);
894 		return ubifs_jnl_write_inode(c, inode);
895 	}
896 
897 	err = ubifs_tnc_remove_ino(c, inode->i_ino);
898 	if (err)
899 		ubifs_ro_mode(c, err);
900 	else
901 		ubifs_delete_orphan(c, inode->i_ino);
902 	up_read(&c->commit_sem);
903 	return err;
904 }
905 
906 /**
907  * ubifs_jnl_rename - rename a directory entry.
908  * @c: UBIFS file-system description object
909  * @old_dir: parent inode of directory entry to rename
910  * @old_dentry: directory entry to rename
911  * @new_dir: parent inode of directory entry to rename
912  * @new_dentry: new directory entry (or directory entry to replace)
913  * @sync: non-zero if the write-buffer has to be synchronized
914  *
915  * This function implements the re-name operation which may involve writing up
916  * to 3 inodes and 2 directory entries. It marks the written inodes as clean
917  * and returns zero on success. In case of failure, a negative error code is
918  * returned.
919  */
ubifs_jnl_rename(struct ubifs_info * c,const struct inode * old_dir,const struct dentry * old_dentry,const struct inode * new_dir,const struct dentry * new_dentry,int sync)920 int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
921 		     const struct dentry *old_dentry,
922 		     const struct inode *new_dir,
923 		     const struct dentry *new_dentry, int sync)
924 {
925 	void *p;
926 	union ubifs_key key;
927 	struct ubifs_dent_node *dent, *dent2;
928 	int err, dlen1, dlen2, ilen, lnum, offs, len;
929 	const struct inode *old_inode = old_dentry->d_inode;
930 	const struct inode *new_inode = new_dentry->d_inode;
931 	int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
932 	int last_reference = !!(new_inode && new_inode->i_nlink == 0);
933 	int move = (old_dir != new_dir);
934 	struct ubifs_inode *uninitialized_var(new_ui);
935 
936 	dbg_jnl("dent '%.*s' in dir ino %lu to dent '%.*s' in dir ino %lu",
937 		old_dentry->d_name.len, old_dentry->d_name.name,
938 		old_dir->i_ino, new_dentry->d_name.len,
939 		new_dentry->d_name.name, new_dir->i_ino);
940 	ubifs_assert(ubifs_inode(old_dir)->data_len == 0);
941 	ubifs_assert(ubifs_inode(new_dir)->data_len == 0);
942 	ubifs_assert(mutex_is_locked(&ubifs_inode(old_dir)->ui_mutex));
943 	ubifs_assert(mutex_is_locked(&ubifs_inode(new_dir)->ui_mutex));
944 
945 	dlen1 = UBIFS_DENT_NODE_SZ + new_dentry->d_name.len + 1;
946 	dlen2 = UBIFS_DENT_NODE_SZ + old_dentry->d_name.len + 1;
947 	if (new_inode) {
948 		new_ui = ubifs_inode(new_inode);
949 		ubifs_assert(mutex_is_locked(&new_ui->ui_mutex));
950 		ilen = UBIFS_INO_NODE_SZ;
951 		if (!last_reference)
952 			ilen += new_ui->data_len;
953 	} else
954 		ilen = 0;
955 
956 	aligned_dlen1 = ALIGN(dlen1, 8);
957 	aligned_dlen2 = ALIGN(dlen2, 8);
958 	len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
959 	if (old_dir != new_dir)
960 		len += plen;
961 	dent = kmalloc(len, GFP_NOFS);
962 	if (!dent)
963 		return -ENOMEM;
964 
965 	/* Make reservation before allocating sequence numbers */
966 	err = make_reservation(c, BASEHD, len);
967 	if (err)
968 		goto out_free;
969 
970 	/* Make new dent */
971 	dent->ch.node_type = UBIFS_DENT_NODE;
972 	dent_key_init_flash(c, &dent->key, new_dir->i_ino, &new_dentry->d_name);
973 	dent->inum = cpu_to_le64(old_inode->i_ino);
974 	dent->type = get_dent_type(old_inode->i_mode);
975 	dent->nlen = cpu_to_le16(new_dentry->d_name.len);
976 	memcpy(dent->name, new_dentry->d_name.name, new_dentry->d_name.len);
977 	dent->name[new_dentry->d_name.len] = '\0';
978 	zero_dent_node_unused(dent);
979 	ubifs_prep_grp_node(c, dent, dlen1, 0);
980 
981 	/* Make deletion dent */
982 	dent2 = (void *)dent + aligned_dlen1;
983 	dent2->ch.node_type = UBIFS_DENT_NODE;
984 	dent_key_init_flash(c, &dent2->key, old_dir->i_ino,
985 			    &old_dentry->d_name);
986 	dent2->inum = 0;
987 	dent2->type = DT_UNKNOWN;
988 	dent2->nlen = cpu_to_le16(old_dentry->d_name.len);
989 	memcpy(dent2->name, old_dentry->d_name.name, old_dentry->d_name.len);
990 	dent2->name[old_dentry->d_name.len] = '\0';
991 	zero_dent_node_unused(dent2);
992 	ubifs_prep_grp_node(c, dent2, dlen2, 0);
993 
994 	p = (void *)dent2 + aligned_dlen2;
995 	if (new_inode) {
996 		pack_inode(c, p, new_inode, 0);
997 		p += ALIGN(ilen, 8);
998 	}
999 
1000 	if (!move)
1001 		pack_inode(c, p, old_dir, 1);
1002 	else {
1003 		pack_inode(c, p, old_dir, 0);
1004 		p += ALIGN(plen, 8);
1005 		pack_inode(c, p, new_dir, 1);
1006 	}
1007 
1008 	if (last_reference) {
1009 		err = ubifs_add_orphan(c, new_inode->i_ino);
1010 		if (err) {
1011 			release_head(c, BASEHD);
1012 			goto out_finish;
1013 		}
1014 		new_ui->del_cmtno = c->cmt_no;
1015 	}
1016 
1017 	err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
1018 	if (err)
1019 		goto out_release;
1020 	if (!sync) {
1021 		struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1022 
1023 		ubifs_wbuf_add_ino_nolock(wbuf, new_dir->i_ino);
1024 		ubifs_wbuf_add_ino_nolock(wbuf, old_dir->i_ino);
1025 		if (new_inode)
1026 			ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
1027 						  new_inode->i_ino);
1028 	}
1029 	release_head(c, BASEHD);
1030 
1031 	dent_key_init(c, &key, new_dir->i_ino, &new_dentry->d_name);
1032 	err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, &new_dentry->d_name);
1033 	if (err)
1034 		goto out_ro;
1035 
1036 	err = ubifs_add_dirt(c, lnum, dlen2);
1037 	if (err)
1038 		goto out_ro;
1039 
1040 	dent_key_init(c, &key, old_dir->i_ino, &old_dentry->d_name);
1041 	err = ubifs_tnc_remove_nm(c, &key, &old_dentry->d_name);
1042 	if (err)
1043 		goto out_ro;
1044 
1045 	offs += aligned_dlen1 + aligned_dlen2;
1046 	if (new_inode) {
1047 		ino_key_init(c, &key, new_inode->i_ino);
1048 		err = ubifs_tnc_add(c, &key, lnum, offs, ilen);
1049 		if (err)
1050 			goto out_ro;
1051 		offs += ALIGN(ilen, 8);
1052 	}
1053 
1054 	ino_key_init(c, &key, old_dir->i_ino);
1055 	err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1056 	if (err)
1057 		goto out_ro;
1058 
1059 	if (old_dir != new_dir) {
1060 		offs += ALIGN(plen, 8);
1061 		ino_key_init(c, &key, new_dir->i_ino);
1062 		err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1063 		if (err)
1064 			goto out_ro;
1065 	}
1066 
1067 	finish_reservation(c);
1068 	if (new_inode) {
1069 		mark_inode_clean(c, new_ui);
1070 		spin_lock(&new_ui->ui_lock);
1071 		new_ui->synced_i_size = new_ui->ui_size;
1072 		spin_unlock(&new_ui->ui_lock);
1073 	}
1074 	mark_inode_clean(c, ubifs_inode(old_dir));
1075 	if (move)
1076 		mark_inode_clean(c, ubifs_inode(new_dir));
1077 	kfree(dent);
1078 	return 0;
1079 
1080 out_release:
1081 	release_head(c, BASEHD);
1082 out_ro:
1083 	ubifs_ro_mode(c, err);
1084 	if (last_reference)
1085 		ubifs_delete_orphan(c, new_inode->i_ino);
1086 out_finish:
1087 	finish_reservation(c);
1088 out_free:
1089 	kfree(dent);
1090 	return err;
1091 }
1092 
1093 /**
1094  * recomp_data_node - re-compress a truncated data node.
1095  * @dn: data node to re-compress
1096  * @new_len: new length
1097  *
1098  * This function is used when an inode is truncated and the last data node of
1099  * the inode has to be re-compressed and re-written.
1100  */
recomp_data_node(struct ubifs_data_node * dn,int * new_len)1101 static int recomp_data_node(struct ubifs_data_node *dn, int *new_len)
1102 {
1103 	void *buf;
1104 	int err, len, compr_type, out_len;
1105 
1106 	out_len = le32_to_cpu(dn->size);
1107 	buf = kmalloc(out_len * WORST_COMPR_FACTOR, GFP_NOFS);
1108 	if (!buf)
1109 		return -ENOMEM;
1110 
1111 	len = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1112 	compr_type = le16_to_cpu(dn->compr_type);
1113 	err = ubifs_decompress(&dn->data, len, buf, &out_len, compr_type);
1114 	if (err)
1115 		goto out;
1116 
1117 	ubifs_compress(buf, *new_len, &dn->data, &out_len, &compr_type);
1118 	ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
1119 	dn->compr_type = cpu_to_le16(compr_type);
1120 	dn->size = cpu_to_le32(*new_len);
1121 	*new_len = UBIFS_DATA_NODE_SZ + out_len;
1122 out:
1123 	kfree(buf);
1124 	return err;
1125 }
1126 
1127 /**
1128  * ubifs_jnl_truncate - update the journal for a truncation.
1129  * @c: UBIFS file-system description object
1130  * @inode: inode to truncate
1131  * @old_size: old size
1132  * @new_size: new size
1133  *
1134  * When the size of a file decreases due to truncation, a truncation node is
1135  * written, the journal tree is updated, and the last data block is re-written
1136  * if it has been affected. The inode is also updated in order to synchronize
1137  * the new inode size.
1138  *
1139  * This function marks the inode as clean and returns zero on success. In case
1140  * of failure, a negative error code is returned.
1141  */
ubifs_jnl_truncate(struct ubifs_info * c,const struct inode * inode,loff_t old_size,loff_t new_size)1142 int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
1143 		       loff_t old_size, loff_t new_size)
1144 {
1145 	union ubifs_key key, to_key;
1146 	struct ubifs_ino_node *ino;
1147 	struct ubifs_trun_node *trun;
1148 	struct ubifs_data_node *uninitialized_var(dn);
1149 	int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
1150 	struct ubifs_inode *ui = ubifs_inode(inode);
1151 	ino_t inum = inode->i_ino;
1152 	unsigned int blk;
1153 
1154 	dbg_jnl("ino %lu, size %lld -> %lld",
1155 		(unsigned long)inum, old_size, new_size);
1156 	ubifs_assert(!ui->data_len);
1157 	ubifs_assert(S_ISREG(inode->i_mode));
1158 	ubifs_assert(mutex_is_locked(&ui->ui_mutex));
1159 
1160 	sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
1161 	     UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
1162 	ino = kmalloc(sz, GFP_NOFS);
1163 	if (!ino)
1164 		return -ENOMEM;
1165 
1166 	trun = (void *)ino + UBIFS_INO_NODE_SZ;
1167 	trun->ch.node_type = UBIFS_TRUN_NODE;
1168 	trun->inum = cpu_to_le32(inum);
1169 	trun->old_size = cpu_to_le64(old_size);
1170 	trun->new_size = cpu_to_le64(new_size);
1171 	zero_trun_node_unused(trun);
1172 
1173 	dlen = new_size & (UBIFS_BLOCK_SIZE - 1);
1174 	if (dlen) {
1175 		/* Get last data block so it can be truncated */
1176 		dn = (void *)trun + UBIFS_TRUN_NODE_SZ;
1177 		blk = new_size >> UBIFS_BLOCK_SHIFT;
1178 		data_key_init(c, &key, inum, blk);
1179 		dbg_jnlk(&key, "last block key ");
1180 		err = ubifs_tnc_lookup(c, &key, dn);
1181 		if (err == -ENOENT)
1182 			dlen = 0; /* Not found (so it is a hole) */
1183 		else if (err)
1184 			goto out_free;
1185 		else {
1186 			if (le32_to_cpu(dn->size) <= dlen)
1187 				dlen = 0; /* Nothing to do */
1188 			else {
1189 				int compr_type = le16_to_cpu(dn->compr_type);
1190 
1191 				if (compr_type != UBIFS_COMPR_NONE) {
1192 					err = recomp_data_node(dn, &dlen);
1193 					if (err)
1194 						goto out_free;
1195 				} else {
1196 					dn->size = cpu_to_le32(dlen);
1197 					dlen += UBIFS_DATA_NODE_SZ;
1198 				}
1199 				zero_data_node_unused(dn);
1200 			}
1201 		}
1202 	}
1203 
1204 	/* Must make reservation before allocating sequence numbers */
1205 	len = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ;
1206 	if (dlen)
1207 		len += dlen;
1208 	err = make_reservation(c, BASEHD, len);
1209 	if (err)
1210 		goto out_free;
1211 
1212 	pack_inode(c, ino, inode, 0);
1213 	ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
1214 	if (dlen)
1215 		ubifs_prep_grp_node(c, dn, dlen, 1);
1216 
1217 	err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
1218 	if (err)
1219 		goto out_release;
1220 	if (!sync)
1221 		ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
1222 	release_head(c, BASEHD);
1223 
1224 	if (dlen) {
1225 		sz = offs + UBIFS_INO_NODE_SZ + UBIFS_TRUN_NODE_SZ;
1226 		err = ubifs_tnc_add(c, &key, lnum, sz, dlen);
1227 		if (err)
1228 			goto out_ro;
1229 	}
1230 
1231 	ino_key_init(c, &key, inum);
1232 	err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ);
1233 	if (err)
1234 		goto out_ro;
1235 
1236 	err = ubifs_add_dirt(c, lnum, UBIFS_TRUN_NODE_SZ);
1237 	if (err)
1238 		goto out_ro;
1239 
1240 	bit = new_size & (UBIFS_BLOCK_SIZE - 1);
1241 	blk = (new_size >> UBIFS_BLOCK_SHIFT) + (bit ? 1 : 0);
1242 	data_key_init(c, &key, inum, blk);
1243 
1244 	bit = old_size & (UBIFS_BLOCK_SIZE - 1);
1245 	blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0 : 1);
1246 	data_key_init(c, &to_key, inum, blk);
1247 
1248 	err = ubifs_tnc_remove_range(c, &key, &to_key);
1249 	if (err)
1250 		goto out_ro;
1251 
1252 	finish_reservation(c);
1253 	spin_lock(&ui->ui_lock);
1254 	ui->synced_i_size = ui->ui_size;
1255 	spin_unlock(&ui->ui_lock);
1256 	mark_inode_clean(c, ui);
1257 	kfree(ino);
1258 	return 0;
1259 
1260 out_release:
1261 	release_head(c, BASEHD);
1262 out_ro:
1263 	ubifs_ro_mode(c, err);
1264 	finish_reservation(c);
1265 out_free:
1266 	kfree(ino);
1267 	return err;
1268 }
1269 
1270 #ifdef CONFIG_UBIFS_FS_XATTR
1271 
1272 /**
1273  * ubifs_jnl_delete_xattr - delete an extended attribute.
1274  * @c: UBIFS file-system description object
1275  * @host: host inode
1276  * @inode: extended attribute inode
1277  * @nm: extended attribute entry name
1278  *
1279  * This function delete an extended attribute which is very similar to
1280  * un-linking regular files - it writes a deletion xentry, a deletion inode and
1281  * updates the target inode. Returns zero in case of success and a negative
1282  * error code in case of failure.
1283  */
ubifs_jnl_delete_xattr(struct ubifs_info * c,const struct inode * host,const struct inode * inode,const struct qstr * nm)1284 int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
1285 			   const struct inode *inode, const struct qstr *nm)
1286 {
1287 	int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen;
1288 	struct ubifs_dent_node *xent;
1289 	struct ubifs_ino_node *ino;
1290 	union ubifs_key xent_key, key1, key2;
1291 	int sync = IS_DIRSYNC(host);
1292 	struct ubifs_inode *host_ui = ubifs_inode(host);
1293 
1294 	dbg_jnl("host %lu, xattr ino %lu, name '%s', data len %d",
1295 		host->i_ino, inode->i_ino, nm->name,
1296 		ubifs_inode(inode)->data_len);
1297 	ubifs_assert(inode->i_nlink == 0);
1298 	ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
1299 
1300 	/*
1301 	 * Since we are deleting the inode, we do not bother to attach any data
1302 	 * to it and assume its length is %UBIFS_INO_NODE_SZ.
1303 	 */
1304 	xlen = UBIFS_DENT_NODE_SZ + nm->len + 1;
1305 	aligned_xlen = ALIGN(xlen, 8);
1306 	hlen = host_ui->data_len + UBIFS_INO_NODE_SZ;
1307 	len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
1308 
1309 	xent = kmalloc(len, GFP_NOFS);
1310 	if (!xent)
1311 		return -ENOMEM;
1312 
1313 	/* Make reservation before allocating sequence numbers */
1314 	err = make_reservation(c, BASEHD, len);
1315 	if (err) {
1316 		kfree(xent);
1317 		return err;
1318 	}
1319 
1320 	xent->ch.node_type = UBIFS_XENT_NODE;
1321 	xent_key_init(c, &xent_key, host->i_ino, nm);
1322 	key_write(c, &xent_key, xent->key);
1323 	xent->inum = 0;
1324 	xent->type = get_dent_type(inode->i_mode);
1325 	xent->nlen = cpu_to_le16(nm->len);
1326 	memcpy(xent->name, nm->name, nm->len);
1327 	xent->name[nm->len] = '\0';
1328 	zero_dent_node_unused(xent);
1329 	ubifs_prep_grp_node(c, xent, xlen, 0);
1330 
1331 	ino = (void *)xent + aligned_xlen;
1332 	pack_inode(c, ino, inode, 0);
1333 	ino = (void *)ino + UBIFS_INO_NODE_SZ;
1334 	pack_inode(c, ino, host, 1);
1335 
1336 	err = write_head(c, BASEHD, xent, len, &lnum, &xent_offs, sync);
1337 	if (!sync && !err)
1338 		ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
1339 	release_head(c, BASEHD);
1340 	kfree(xent);
1341 	if (err)
1342 		goto out_ro;
1343 
1344 	/* Remove the extended attribute entry from TNC */
1345 	err = ubifs_tnc_remove_nm(c, &xent_key, nm);
1346 	if (err)
1347 		goto out_ro;
1348 	err = ubifs_add_dirt(c, lnum, xlen);
1349 	if (err)
1350 		goto out_ro;
1351 
1352 	/*
1353 	 * Remove all nodes belonging to the extended attribute inode from TNC.
1354 	 * Well, there actually must be only one node - the inode itself.
1355 	 */
1356 	lowest_ino_key(c, &key1, inode->i_ino);
1357 	highest_ino_key(c, &key2, inode->i_ino);
1358 	err = ubifs_tnc_remove_range(c, &key1, &key2);
1359 	if (err)
1360 		goto out_ro;
1361 	err = ubifs_add_dirt(c, lnum, UBIFS_INO_NODE_SZ);
1362 	if (err)
1363 		goto out_ro;
1364 
1365 	/* And update TNC with the new host inode position */
1366 	ino_key_init(c, &key1, host->i_ino);
1367 	err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen);
1368 	if (err)
1369 		goto out_ro;
1370 
1371 	finish_reservation(c);
1372 	spin_lock(&host_ui->ui_lock);
1373 	host_ui->synced_i_size = host_ui->ui_size;
1374 	spin_unlock(&host_ui->ui_lock);
1375 	mark_inode_clean(c, host_ui);
1376 	return 0;
1377 
1378 out_ro:
1379 	ubifs_ro_mode(c, err);
1380 	finish_reservation(c);
1381 	return err;
1382 }
1383 
1384 /**
1385  * ubifs_jnl_change_xattr - change an extended attribute.
1386  * @c: UBIFS file-system description object
1387  * @inode: extended attribute inode
1388  * @host: host inode
1389  *
1390  * This function writes the updated version of an extended attribute inode and
1391  * the host inode to the journal (to the base head). The host inode is written
1392  * after the extended attribute inode in order to guarantee that the extended
1393  * attribute will be flushed when the inode is synchronized by 'fsync()' and
1394  * consequently, the write-buffer is synchronized. This function returns zero
1395  * in case of success and a negative error code in case of failure.
1396  */
ubifs_jnl_change_xattr(struct ubifs_info * c,const struct inode * inode,const struct inode * host)1397 int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
1398 			   const struct inode *host)
1399 {
1400 	int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
1401 	struct ubifs_inode *host_ui = ubifs_inode(host);
1402 	struct ubifs_ino_node *ino;
1403 	union ubifs_key key;
1404 	int sync = IS_DIRSYNC(host);
1405 
1406 	dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1407 	ubifs_assert(host->i_nlink > 0);
1408 	ubifs_assert(inode->i_nlink > 0);
1409 	ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
1410 
1411 	len1 = UBIFS_INO_NODE_SZ + host_ui->data_len;
1412 	len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode)->data_len;
1413 	aligned_len1 = ALIGN(len1, 8);
1414 	aligned_len = aligned_len1 + ALIGN(len2, 8);
1415 
1416 	ino = kmalloc(aligned_len, GFP_NOFS);
1417 	if (!ino)
1418 		return -ENOMEM;
1419 
1420 	/* Make reservation before allocating sequence numbers */
1421 	err = make_reservation(c, BASEHD, aligned_len);
1422 	if (err)
1423 		goto out_free;
1424 
1425 	pack_inode(c, ino, host, 0);
1426 	pack_inode(c, (void *)ino + aligned_len1, inode, 1);
1427 
1428 	err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
1429 	if (!sync && !err) {
1430 		struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1431 
1432 		ubifs_wbuf_add_ino_nolock(wbuf, host->i_ino);
1433 		ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
1434 	}
1435 	release_head(c, BASEHD);
1436 	if (err)
1437 		goto out_ro;
1438 
1439 	ino_key_init(c, &key, host->i_ino);
1440 	err = ubifs_tnc_add(c, &key, lnum, offs, len1);
1441 	if (err)
1442 		goto out_ro;
1443 
1444 	ino_key_init(c, &key, inode->i_ino);
1445 	err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2);
1446 	if (err)
1447 		goto out_ro;
1448 
1449 	finish_reservation(c);
1450 	spin_lock(&host_ui->ui_lock);
1451 	host_ui->synced_i_size = host_ui->ui_size;
1452 	spin_unlock(&host_ui->ui_lock);
1453 	mark_inode_clean(c, host_ui);
1454 	kfree(ino);
1455 	return 0;
1456 
1457 out_ro:
1458 	ubifs_ro_mode(c, err);
1459 	finish_reservation(c);
1460 out_free:
1461 	kfree(ino);
1462 	return err;
1463 }
1464 
1465 #endif /* CONFIG_UBIFS_FS_XATTR */
1466