This source file includes following definitions.
- zero_ino_node_unused
- zero_dent_node_unused
- zero_trun_node_unused
- ubifs_add_auth_dirt
- reserve_space
- ubifs_hash_nodes
- write_head
- make_reservation
- release_head
- finish_reservation
- get_dent_type
- pack_inode
- mark_inode_clean
- set_dent_cookie
- ubifs_jnl_update
- ubifs_jnl_write_data
- ubifs_jnl_write_inode
- ubifs_jnl_delete_inode
- ubifs_jnl_xrename
- ubifs_jnl_rename
- truncate_data_node
- ubifs_jnl_truncate
- ubifs_jnl_delete_xattr
- ubifs_jnl_change_xattr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 #include "ubifs.h"
50
51
52
53
54
55 static inline void zero_ino_node_unused(struct ubifs_ino_node *ino)
56 {
57 memset(ino->padding1, 0, 4);
58 memset(ino->padding2, 0, 26);
59 }
60
61
62
63
64
65
66 static inline void zero_dent_node_unused(struct ubifs_dent_node *dent)
67 {
68 dent->padding1 = 0;
69 }
70
71
72
73
74
75
76 static inline void zero_trun_node_unused(struct ubifs_trun_node *trun)
77 {
78 memset(trun->padding, 0, 12);
79 }
80
81 static void ubifs_add_auth_dirt(struct ubifs_info *c, int lnum)
82 {
83 if (ubifs_authenticated(c))
84 ubifs_add_dirt(c, lnum, ubifs_auth_node_sz(c));
85 }
86
87
88
89
90
91
92
93
94
95
96
97
98 static int reserve_space(struct ubifs_info *c, int jhead, int len)
99 {
100 int err = 0, err1, retries = 0, avail, lnum, offs, squeeze;
101 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
102
103
104
105
106
107
108 ubifs_assert(c, !c->ro_media && !c->ro_mount);
109 squeeze = (jhead == BASEHD);
110 again:
111 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
112
113 if (c->ro_error) {
114 err = -EROFS;
115 goto out_unlock;
116 }
117
118 avail = c->leb_size - wbuf->offs - wbuf->used;
119 if (wbuf->lnum != -1 && avail >= len)
120 return 0;
121
122
123
124
125
126 lnum = ubifs_find_free_space(c, len, &offs, squeeze);
127 if (lnum >= 0)
128 goto out;
129
130 err = lnum;
131 if (err != -ENOSPC)
132 goto out_unlock;
133
134
135
136
137
138
139 dbg_jnl("no free space in jhead %s, run GC", dbg_jhead(jhead));
140 mutex_unlock(&wbuf->io_mutex);
141
142 lnum = ubifs_garbage_collect(c, 0);
143 if (lnum < 0) {
144 err = lnum;
145 if (err != -ENOSPC)
146 return err;
147
148
149
150
151
152
153
154 dbg_jnl("GC couldn't make a free LEB for jhead %s",
155 dbg_jhead(jhead));
156 if (retries++ < 2) {
157 dbg_jnl("retry (%d)", retries);
158 goto again;
159 }
160
161 dbg_jnl("return -ENOSPC");
162 return err;
163 }
164
165 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
166 dbg_jnl("got LEB %d for jhead %s", lnum, dbg_jhead(jhead));
167 avail = c->leb_size - wbuf->offs - wbuf->used;
168
169 if (wbuf->lnum != -1 && avail >= len) {
170
171
172
173
174
175 dbg_jnl("return LEB %d back, already have LEB %d:%d",
176 lnum, wbuf->lnum, wbuf->offs + wbuf->used);
177 err = ubifs_return_leb(c, lnum);
178 if (err)
179 goto out_unlock;
180 return 0;
181 }
182
183 offs = 0;
184
185 out:
186
187
188
189
190
191
192
193
194 err = ubifs_wbuf_sync_nolock(wbuf);
195 if (err)
196 goto out_return;
197 err = ubifs_add_bud_to_log(c, jhead, lnum, offs);
198 if (err)
199 goto out_return;
200 err = ubifs_wbuf_seek_nolock(wbuf, lnum, offs);
201 if (err)
202 goto out_unlock;
203
204 return 0;
205
206 out_unlock:
207 mutex_unlock(&wbuf->io_mutex);
208 return err;
209
210 out_return:
211
212 ubifs_assert(c, err < 0);
213 err1 = ubifs_return_leb(c, lnum);
214 if (err1 && err == -EAGAIN)
215
216
217
218
219
220 err = err1;
221 mutex_unlock(&wbuf->io_mutex);
222 return err;
223 }
224
225 static int ubifs_hash_nodes(struct ubifs_info *c, void *node,
226 int len, struct shash_desc *hash)
227 {
228 int auth_node_size = ubifs_auth_node_sz(c);
229 int err;
230
231 while (1) {
232 const struct ubifs_ch *ch = node;
233 int nodelen = le32_to_cpu(ch->len);
234
235 ubifs_assert(c, len >= auth_node_size);
236
237 if (len == auth_node_size)
238 break;
239
240 ubifs_assert(c, len > nodelen);
241 ubifs_assert(c, ch->magic == cpu_to_le32(UBIFS_NODE_MAGIC));
242
243 err = ubifs_shash_update(c, hash, (void *)node, nodelen);
244 if (err)
245 return err;
246
247 node += ALIGN(nodelen, 8);
248 len -= ALIGN(nodelen, 8);
249 }
250
251 return ubifs_prepare_auth_node(c, node, hash);
252 }
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268 static int write_head(struct ubifs_info *c, int jhead, void *buf, int len,
269 int *lnum, int *offs, int sync)
270 {
271 int err;
272 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
273
274 ubifs_assert(c, jhead != GCHD);
275
276 *lnum = c->jheads[jhead].wbuf.lnum;
277 *offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
278 dbg_jnl("jhead %s, LEB %d:%d, len %d",
279 dbg_jhead(jhead), *lnum, *offs, len);
280
281 if (ubifs_authenticated(c)) {
282 err = ubifs_hash_nodes(c, buf, len, c->jheads[jhead].log_hash);
283 if (err)
284 return err;
285 }
286
287 err = ubifs_wbuf_write_nolock(wbuf, buf, len);
288 if (err)
289 return err;
290 if (sync)
291 err = ubifs_wbuf_sync_nolock(wbuf);
292 return err;
293 }
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311 static int make_reservation(struct ubifs_info *c, int jhead, int len)
312 {
313 int err, cmt_retries = 0, nospc_retries = 0;
314
315 again:
316 down_read(&c->commit_sem);
317 err = reserve_space(c, jhead, len);
318 if (!err)
319
320 return 0;
321 up_read(&c->commit_sem);
322
323 if (err == -ENOSPC) {
324
325
326
327
328
329
330 if (nospc_retries++ < 2) {
331 dbg_jnl("no space, retry");
332 err = -EAGAIN;
333 }
334
335
336
337
338
339
340
341 }
342
343 if (err != -EAGAIN)
344 goto out;
345
346
347
348
349
350 if (cmt_retries > 128) {
351
352
353
354
355 ubifs_err(c, "stuck in space allocation");
356 err = -ENOSPC;
357 goto out;
358 } else if (cmt_retries > 32)
359 ubifs_warn(c, "too many space allocation re-tries (%d)",
360 cmt_retries);
361
362 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
363 cmt_retries);
364 cmt_retries += 1;
365
366 err = ubifs_run_commit(c);
367 if (err)
368 return err;
369 goto again;
370
371 out:
372 ubifs_err(c, "cannot reserve %d bytes in jhead %d, error %d",
373 len, jhead, err);
374 if (err == -ENOSPC) {
375
376 down_write(&c->commit_sem);
377 dump_stack();
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);
382 }
383 return err;
384 }
385
386
387
388
389
390
391
392
393
394
395 static inline void release_head(struct ubifs_info *c, int jhead)
396 {
397 mutex_unlock(&c->jheads[jhead].wbuf.io_mutex);
398 }
399
400
401
402
403
404
405
406
407 static void finish_reservation(struct ubifs_info *c)
408 {
409 up_read(&c->commit_sem);
410 }
411
412
413
414
415
416 static int get_dent_type(int mode)
417 {
418 switch (mode & S_IFMT) {
419 case S_IFREG:
420 return UBIFS_ITYPE_REG;
421 case S_IFDIR:
422 return UBIFS_ITYPE_DIR;
423 case S_IFLNK:
424 return UBIFS_ITYPE_LNK;
425 case S_IFBLK:
426 return UBIFS_ITYPE_BLK;
427 case S_IFCHR:
428 return UBIFS_ITYPE_CHR;
429 case S_IFIFO:
430 return UBIFS_ITYPE_FIFO;
431 case S_IFSOCK:
432 return UBIFS_ITYPE_SOCK;
433 default:
434 BUG();
435 }
436 return 0;
437 }
438
439
440
441
442
443
444
445
446 static void pack_inode(struct ubifs_info *c, struct ubifs_ino_node *ino,
447 const struct inode *inode, int last)
448 {
449 int data_len = 0, last_reference = !inode->i_nlink;
450 struct ubifs_inode *ui = ubifs_inode(inode);
451
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);
473
474
475
476
477
478 if (!last_reference) {
479 memcpy(ino->data, ui->data, ui->data_len);
480 data_len = ui->data_len;
481 }
482
483 ubifs_prep_grp_node(c, ino, UBIFS_INO_NODE_SZ + data_len, last);
484 }
485
486
487
488
489
490
491
492
493
494
495
496 static void mark_inode_clean(struct ubifs_info *c, struct ubifs_inode *ui)
497 {
498 if (ui->dirty)
499 ubifs_release_dirty_inode_budget(c, ui);
500 ui->dirty = 0;
501 }
502
503 static void set_dent_cookie(struct ubifs_info *c, struct ubifs_dent_node *dent)
504 {
505 if (c->double_hash)
506 dent->cookie = prandom_u32();
507 else
508 dent->cookie = 0;
509 }
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
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)
541 {
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;
550 u8 hash_dent[UBIFS_HASH_ARR_SZ];
551 u8 hash_ino[UBIFS_HASH_ARR_SZ];
552 u8 hash_ino_host[UBIFS_HASH_ARR_SZ];
553
554 ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
555
556 dlen = UBIFS_DENT_NODE_SZ + fname_len(nm) + 1;
557 ilen = UBIFS_INO_NODE_SZ;
558
559
560
561
562
563
564
565 if (!last_reference) {
566 ilen += ui->data_len;
567 sync |= IS_SYNC(inode);
568 }
569
570 aligned_dlen = ALIGN(dlen, 8);
571 aligned_ilen = ALIGN(ilen, 8);
572
573 len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
574
575 if (ubifs_authenticated(c))
576 len += ALIGN(host_ui->data_len, 8) + ubifs_auth_node_sz(c);
577 else
578 len += host_ui->data_len;
579
580 dent = kzalloc(len, GFP_NOFS);
581 if (!dent)
582 return -ENOMEM;
583
584
585 err = make_reservation(c, BASEHD, len);
586 if (err)
587 goto out_free;
588
589 if (!xent) {
590 dent->ch.node_type = UBIFS_DENT_NODE;
591 if (nm->hash)
592 dent_key_init_hash(c, &dent_key, dir->i_ino, nm->hash);
593 else
594 dent_key_init(c, &dent_key, dir->i_ino, nm);
595 } else {
596 dent->ch.node_type = UBIFS_XENT_NODE;
597 xent_key_init(c, &dent_key, dir->i_ino, nm);
598 }
599
600 key_write(c, &dent_key, dent->key);
601 dent->inum = deletion ? 0 : cpu_to_le64(inode->i_ino);
602 dent->type = get_dent_type(inode->i_mode);
603 dent->nlen = cpu_to_le16(fname_len(nm));
604 memcpy(dent->name, fname_name(nm), fname_len(nm));
605 dent->name[fname_len(nm)] = '\0';
606 set_dent_cookie(c, dent);
607
608 zero_dent_node_unused(dent);
609 ubifs_prep_grp_node(c, dent, dlen, 0);
610 err = ubifs_node_calc_hash(c, dent, hash_dent);
611 if (err)
612 goto out_release;
613
614 ino = (void *)dent + aligned_dlen;
615 pack_inode(c, ino, inode, 0);
616 err = ubifs_node_calc_hash(c, ino, hash_ino);
617 if (err)
618 goto out_release;
619
620 ino = (void *)ino + aligned_ilen;
621 pack_inode(c, ino, dir, 1);
622 err = ubifs_node_calc_hash(c, ino, hash_ino_host);
623 if (err)
624 goto out_release;
625
626 if (last_reference) {
627 err = ubifs_add_orphan(c, inode->i_ino);
628 if (err) {
629 release_head(c, BASEHD);
630 goto out_finish;
631 }
632 ui->del_cmtno = c->cmt_no;
633 }
634
635 err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
636 if (err)
637 goto out_release;
638 if (!sync) {
639 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
640
641 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
642 ubifs_wbuf_add_ino_nolock(wbuf, dir->i_ino);
643 }
644 release_head(c, BASEHD);
645 kfree(dent);
646 ubifs_add_auth_dirt(c, lnum);
647
648 if (deletion) {
649 if (nm->hash)
650 err = ubifs_tnc_remove_dh(c, &dent_key, nm->minor_hash);
651 else
652 err = ubifs_tnc_remove_nm(c, &dent_key, nm);
653 if (err)
654 goto out_ro;
655 err = ubifs_add_dirt(c, lnum, dlen);
656 } else
657 err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen,
658 hash_dent, nm);
659 if (err)
660 goto out_ro;
661
662
663
664
665
666
667
668 ino_key_init(c, &ino_key, inode->i_ino);
669 ino_offs = dent_offs + aligned_dlen;
670 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen, hash_ino);
671 if (err)
672 goto out_ro;
673
674 ino_key_init(c, &ino_key, dir->i_ino);
675 ino_offs += aligned_ilen;
676 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs,
677 UBIFS_INO_NODE_SZ + host_ui->data_len, hash_ino_host);
678 if (err)
679 goto out_ro;
680
681 finish_reservation(c);
682 spin_lock(&ui->ui_lock);
683 ui->synced_i_size = ui->ui_size;
684 spin_unlock(&ui->ui_lock);
685 if (xent) {
686 spin_lock(&host_ui->ui_lock);
687 host_ui->synced_i_size = host_ui->ui_size;
688 spin_unlock(&host_ui->ui_lock);
689 }
690 mark_inode_clean(c, ui);
691 mark_inode_clean(c, host_ui);
692 return 0;
693
694 out_finish:
695 finish_reservation(c);
696 out_free:
697 kfree(dent);
698 return err;
699
700 out_release:
701 release_head(c, BASEHD);
702 kfree(dent);
703 out_ro:
704 ubifs_ro_mode(c, err);
705 if (last_reference)
706 ubifs_delete_orphan(c, inode->i_ino);
707 finish_reservation(c);
708 return err;
709 }
710
711
712
713
714
715
716
717
718
719
720
721
722 int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
723 const union ubifs_key *key, const void *buf, int len)
724 {
725 struct ubifs_data_node *data;
726 int err, lnum, offs, compr_type, out_len, compr_len, auth_len;
727 int dlen = COMPRESSED_DATA_NODE_BUF_SZ, allocated = 1;
728 int write_len;
729 struct ubifs_inode *ui = ubifs_inode(inode);
730 bool encrypted = ubifs_crypt_is_encrypted(inode);
731 u8 hash[UBIFS_HASH_ARR_SZ];
732
733 dbg_jnlk(key, "ino %lu, blk %u, len %d, key ",
734 (unsigned long)key_inum(c, key), key_block(c, key), len);
735 ubifs_assert(c, len <= UBIFS_BLOCK_SIZE);
736
737 if (encrypted)
738 dlen += UBIFS_CIPHER_BLOCK_SIZE;
739
740 auth_len = ubifs_auth_node_sz(c);
741
742 data = kmalloc(dlen + auth_len, GFP_NOFS | __GFP_NOWARN);
743 if (!data) {
744
745
746
747
748
749
750
751 allocated = 0;
752 mutex_lock(&c->write_reserve_mutex);
753 data = c->write_reserve_buf;
754 }
755
756 data->ch.node_type = UBIFS_DATA_NODE;
757 key_write(c, key, &data->key);
758 data->size = cpu_to_le32(len);
759
760 if (!(ui->flags & UBIFS_COMPR_FL))
761
762 compr_type = UBIFS_COMPR_NONE;
763 else
764 compr_type = ui->compr_type;
765
766 out_len = compr_len = dlen - UBIFS_DATA_NODE_SZ;
767 ubifs_compress(c, buf, len, &data->data, &compr_len, &compr_type);
768 ubifs_assert(c, compr_len <= UBIFS_BLOCK_SIZE);
769
770 if (encrypted) {
771 err = ubifs_encrypt(inode, data, compr_len, &out_len, key_block(c, key));
772 if (err)
773 goto out_free;
774
775 } else {
776 data->compr_size = 0;
777 out_len = compr_len;
778 }
779
780 dlen = UBIFS_DATA_NODE_SZ + out_len;
781 if (ubifs_authenticated(c))
782 write_len = ALIGN(dlen, 8) + auth_len;
783 else
784 write_len = dlen;
785
786 data->compr_type = cpu_to_le16(compr_type);
787
788
789 err = make_reservation(c, DATAHD, write_len);
790 if (err)
791 goto out_free;
792
793 ubifs_prepare_node(c, data, dlen, 0);
794 err = write_head(c, DATAHD, data, write_len, &lnum, &offs, 0);
795 if (err)
796 goto out_release;
797
798 err = ubifs_node_calc_hash(c, data, hash);
799 if (err)
800 goto out_release;
801
802 ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf, key_inum(c, key));
803 release_head(c, DATAHD);
804
805 ubifs_add_auth_dirt(c, lnum);
806
807 err = ubifs_tnc_add(c, key, lnum, offs, dlen, hash);
808 if (err)
809 goto out_ro;
810
811 finish_reservation(c);
812 if (!allocated)
813 mutex_unlock(&c->write_reserve_mutex);
814 else
815 kfree(data);
816 return 0;
817
818 out_release:
819 release_head(c, DATAHD);
820 out_ro:
821 ubifs_ro_mode(c, err);
822 finish_reservation(c);
823 out_free:
824 if (!allocated)
825 mutex_unlock(&c->write_reserve_mutex);
826 else
827 kfree(data);
828 return err;
829 }
830
831
832
833
834
835
836
837
838
839
840 int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode)
841 {
842 int err, lnum, offs;
843 struct ubifs_ino_node *ino, *ino_start;
844 struct ubifs_inode *ui = ubifs_inode(inode);
845 int sync = 0, write_len = 0, ilen = UBIFS_INO_NODE_SZ;
846 int last_reference = !inode->i_nlink;
847 int kill_xattrs = ui->xattr_cnt && last_reference;
848 u8 hash[UBIFS_HASH_ARR_SZ];
849
850 dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
851
852
853
854
855
856 if (!last_reference) {
857 ilen += ui->data_len;
858 sync = IS_SYNC(inode);
859 } else if (kill_xattrs) {
860 write_len += UBIFS_INO_NODE_SZ * ui->xattr_cnt;
861 }
862
863 if (ubifs_authenticated(c))
864 write_len += ALIGN(ilen, 8) + ubifs_auth_node_sz(c);
865 else
866 write_len += ilen;
867
868 ino_start = ino = kmalloc(write_len, GFP_NOFS);
869 if (!ino)
870 return -ENOMEM;
871
872
873 err = make_reservation(c, BASEHD, write_len);
874 if (err)
875 goto out_free;
876
877 if (kill_xattrs) {
878 union ubifs_key key;
879 struct fscrypt_name nm = {0};
880 struct inode *xino;
881 struct ubifs_dent_node *xent, *pxent = NULL;
882
883 if (ui->xattr_cnt >= ubifs_xattr_max_cnt(c)) {
884 ubifs_err(c, "Cannot delete inode, it has too much xattrs!");
885 goto out_release;
886 }
887
888 lowest_xent_key(c, &key, inode->i_ino);
889 while (1) {
890 xent = ubifs_tnc_next_ent(c, &key, &nm);
891 if (IS_ERR(xent)) {
892 err = PTR_ERR(xent);
893 if (err == -ENOENT)
894 break;
895
896 goto out_release;
897 }
898
899 fname_name(&nm) = xent->name;
900 fname_len(&nm) = le16_to_cpu(xent->nlen);
901
902 xino = ubifs_iget(c->vfs_sb, le64_to_cpu(xent->inum));
903 if (IS_ERR(xino)) {
904 err = PTR_ERR(xino);
905 ubifs_err(c, "dead directory entry '%s', error %d",
906 xent->name, err);
907 ubifs_ro_mode(c, err);
908 goto out_release;
909 }
910 ubifs_assert(c, ubifs_inode(xino)->xattr);
911
912 clear_nlink(xino);
913 pack_inode(c, ino, xino, 0);
914 ino = (void *)ino + UBIFS_INO_NODE_SZ;
915 iput(xino);
916
917 kfree(pxent);
918 pxent = xent;
919 key_read(c, &xent->key, &key);
920 }
921 kfree(pxent);
922 }
923
924 pack_inode(c, ino, inode, 1);
925 err = ubifs_node_calc_hash(c, ino, hash);
926 if (err)
927 goto out_release;
928
929 err = write_head(c, BASEHD, ino_start, write_len, &lnum, &offs, sync);
930 if (err)
931 goto out_release;
932 if (!sync)
933 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
934 inode->i_ino);
935 release_head(c, BASEHD);
936
937 ubifs_add_auth_dirt(c, lnum);
938
939 if (last_reference) {
940 err = ubifs_tnc_remove_ino(c, inode->i_ino);
941 if (err)
942 goto out_ro;
943 ubifs_delete_orphan(c, inode->i_ino);
944 err = ubifs_add_dirt(c, lnum, write_len);
945 } else {
946 union ubifs_key key;
947
948 ino_key_init(c, &key, inode->i_ino);
949 err = ubifs_tnc_add(c, &key, lnum, offs, ilen, hash);
950 }
951 if (err)
952 goto out_ro;
953
954 finish_reservation(c);
955 spin_lock(&ui->ui_lock);
956 ui->synced_i_size = ui->ui_size;
957 spin_unlock(&ui->ui_lock);
958 kfree(ino_start);
959 return 0;
960
961 out_release:
962 release_head(c, BASEHD);
963 out_ro:
964 ubifs_ro_mode(c, err);
965 finish_reservation(c);
966 out_free:
967 kfree(ino_start);
968 return err;
969 }
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000 int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode)
1001 {
1002 int err;
1003 struct ubifs_inode *ui = ubifs_inode(inode);
1004
1005 ubifs_assert(c, inode->i_nlink == 0);
1006
1007 if (ui->xattr_cnt || ui->del_cmtno != c->cmt_no)
1008
1009 return ubifs_jnl_write_inode(c, inode);
1010
1011 down_read(&c->commit_sem);
1012
1013
1014
1015
1016 if (ui->del_cmtno != c->cmt_no) {
1017 up_read(&c->commit_sem);
1018 return ubifs_jnl_write_inode(c, inode);
1019 }
1020
1021 err = ubifs_tnc_remove_ino(c, inode->i_ino);
1022 if (err)
1023 ubifs_ro_mode(c, err);
1024 else
1025 ubifs_delete_orphan(c, inode->i_ino);
1026 up_read(&c->commit_sem);
1027 return err;
1028 }
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046 int ubifs_jnl_xrename(struct ubifs_info *c, const struct inode *fst_dir,
1047 const struct inode *fst_inode,
1048 const struct fscrypt_name *fst_nm,
1049 const struct inode *snd_dir,
1050 const struct inode *snd_inode,
1051 const struct fscrypt_name *snd_nm, int sync)
1052 {
1053 union ubifs_key key;
1054 struct ubifs_dent_node *dent1, *dent2;
1055 int err, dlen1, dlen2, lnum, offs, len, plen = UBIFS_INO_NODE_SZ;
1056 int aligned_dlen1, aligned_dlen2;
1057 int twoparents = (fst_dir != snd_dir);
1058 void *p;
1059 u8 hash_dent1[UBIFS_HASH_ARR_SZ];
1060 u8 hash_dent2[UBIFS_HASH_ARR_SZ];
1061 u8 hash_p1[UBIFS_HASH_ARR_SZ];
1062 u8 hash_p2[UBIFS_HASH_ARR_SZ];
1063
1064 ubifs_assert(c, ubifs_inode(fst_dir)->data_len == 0);
1065 ubifs_assert(c, ubifs_inode(snd_dir)->data_len == 0);
1066 ubifs_assert(c, mutex_is_locked(&ubifs_inode(fst_dir)->ui_mutex));
1067 ubifs_assert(c, mutex_is_locked(&ubifs_inode(snd_dir)->ui_mutex));
1068
1069 dlen1 = UBIFS_DENT_NODE_SZ + fname_len(snd_nm) + 1;
1070 dlen2 = UBIFS_DENT_NODE_SZ + fname_len(fst_nm) + 1;
1071 aligned_dlen1 = ALIGN(dlen1, 8);
1072 aligned_dlen2 = ALIGN(dlen2, 8);
1073
1074 len = aligned_dlen1 + aligned_dlen2 + ALIGN(plen, 8);
1075 if (twoparents)
1076 len += plen;
1077
1078 len += ubifs_auth_node_sz(c);
1079
1080 dent1 = kzalloc(len, GFP_NOFS);
1081 if (!dent1)
1082 return -ENOMEM;
1083
1084
1085 err = make_reservation(c, BASEHD, len);
1086 if (err)
1087 goto out_free;
1088
1089
1090 dent1->ch.node_type = UBIFS_DENT_NODE;
1091 dent_key_init_flash(c, &dent1->key, snd_dir->i_ino, snd_nm);
1092 dent1->inum = cpu_to_le64(fst_inode->i_ino);
1093 dent1->type = get_dent_type(fst_inode->i_mode);
1094 dent1->nlen = cpu_to_le16(fname_len(snd_nm));
1095 memcpy(dent1->name, fname_name(snd_nm), fname_len(snd_nm));
1096 dent1->name[fname_len(snd_nm)] = '\0';
1097 set_dent_cookie(c, dent1);
1098 zero_dent_node_unused(dent1);
1099 ubifs_prep_grp_node(c, dent1, dlen1, 0);
1100 err = ubifs_node_calc_hash(c, dent1, hash_dent1);
1101 if (err)
1102 goto out_release;
1103
1104
1105 dent2 = (void *)dent1 + aligned_dlen1;
1106 dent2->ch.node_type = UBIFS_DENT_NODE;
1107 dent_key_init_flash(c, &dent2->key, fst_dir->i_ino, fst_nm);
1108 dent2->inum = cpu_to_le64(snd_inode->i_ino);
1109 dent2->type = get_dent_type(snd_inode->i_mode);
1110 dent2->nlen = cpu_to_le16(fname_len(fst_nm));
1111 memcpy(dent2->name, fname_name(fst_nm), fname_len(fst_nm));
1112 dent2->name[fname_len(fst_nm)] = '\0';
1113 set_dent_cookie(c, dent2);
1114 zero_dent_node_unused(dent2);
1115 ubifs_prep_grp_node(c, dent2, dlen2, 0);
1116 err = ubifs_node_calc_hash(c, dent2, hash_dent2);
1117 if (err)
1118 goto out_release;
1119
1120 p = (void *)dent2 + aligned_dlen2;
1121 if (!twoparents) {
1122 pack_inode(c, p, fst_dir, 1);
1123 err = ubifs_node_calc_hash(c, p, hash_p1);
1124 if (err)
1125 goto out_release;
1126 } else {
1127 pack_inode(c, p, fst_dir, 0);
1128 err = ubifs_node_calc_hash(c, p, hash_p1);
1129 if (err)
1130 goto out_release;
1131 p += ALIGN(plen, 8);
1132 pack_inode(c, p, snd_dir, 1);
1133 err = ubifs_node_calc_hash(c, p, hash_p2);
1134 if (err)
1135 goto out_release;
1136 }
1137
1138 err = write_head(c, BASEHD, dent1, len, &lnum, &offs, sync);
1139 if (err)
1140 goto out_release;
1141 if (!sync) {
1142 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1143
1144 ubifs_wbuf_add_ino_nolock(wbuf, fst_dir->i_ino);
1145 ubifs_wbuf_add_ino_nolock(wbuf, snd_dir->i_ino);
1146 }
1147 release_head(c, BASEHD);
1148
1149 ubifs_add_auth_dirt(c, lnum);
1150
1151 dent_key_init(c, &key, snd_dir->i_ino, snd_nm);
1152 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, hash_dent1, snd_nm);
1153 if (err)
1154 goto out_ro;
1155
1156 offs += aligned_dlen1;
1157 dent_key_init(c, &key, fst_dir->i_ino, fst_nm);
1158 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, hash_dent2, fst_nm);
1159 if (err)
1160 goto out_ro;
1161
1162 offs += aligned_dlen2;
1163
1164 ino_key_init(c, &key, fst_dir->i_ino);
1165 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_p1);
1166 if (err)
1167 goto out_ro;
1168
1169 if (twoparents) {
1170 offs += ALIGN(plen, 8);
1171 ino_key_init(c, &key, snd_dir->i_ino);
1172 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_p2);
1173 if (err)
1174 goto out_ro;
1175 }
1176
1177 finish_reservation(c);
1178
1179 mark_inode_clean(c, ubifs_inode(fst_dir));
1180 if (twoparents)
1181 mark_inode_clean(c, ubifs_inode(snd_dir));
1182 kfree(dent1);
1183 return 0;
1184
1185 out_release:
1186 release_head(c, BASEHD);
1187 out_ro:
1188 ubifs_ro_mode(c, err);
1189 finish_reservation(c);
1190 out_free:
1191 kfree(dent1);
1192 return err;
1193 }
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209 int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
1210 const struct inode *old_inode,
1211 const struct fscrypt_name *old_nm,
1212 const struct inode *new_dir,
1213 const struct inode *new_inode,
1214 const struct fscrypt_name *new_nm,
1215 const struct inode *whiteout, int sync)
1216 {
1217 void *p;
1218 union ubifs_key key;
1219 struct ubifs_dent_node *dent, *dent2;
1220 int err, dlen1, dlen2, ilen, lnum, offs, len;
1221 int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
1222 int last_reference = !!(new_inode && new_inode->i_nlink == 0);
1223 int move = (old_dir != new_dir);
1224 struct ubifs_inode *uninitialized_var(new_ui);
1225 u8 hash_old_dir[UBIFS_HASH_ARR_SZ];
1226 u8 hash_new_dir[UBIFS_HASH_ARR_SZ];
1227 u8 hash_new_inode[UBIFS_HASH_ARR_SZ];
1228 u8 hash_dent1[UBIFS_HASH_ARR_SZ];
1229 u8 hash_dent2[UBIFS_HASH_ARR_SZ];
1230
1231 ubifs_assert(c, ubifs_inode(old_dir)->data_len == 0);
1232 ubifs_assert(c, ubifs_inode(new_dir)->data_len == 0);
1233 ubifs_assert(c, mutex_is_locked(&ubifs_inode(old_dir)->ui_mutex));
1234 ubifs_assert(c, mutex_is_locked(&ubifs_inode(new_dir)->ui_mutex));
1235
1236 dlen1 = UBIFS_DENT_NODE_SZ + fname_len(new_nm) + 1;
1237 dlen2 = UBIFS_DENT_NODE_SZ + fname_len(old_nm) + 1;
1238 if (new_inode) {
1239 new_ui = ubifs_inode(new_inode);
1240 ubifs_assert(c, mutex_is_locked(&new_ui->ui_mutex));
1241 ilen = UBIFS_INO_NODE_SZ;
1242 if (!last_reference)
1243 ilen += new_ui->data_len;
1244 } else
1245 ilen = 0;
1246
1247 aligned_dlen1 = ALIGN(dlen1, 8);
1248 aligned_dlen2 = ALIGN(dlen2, 8);
1249 len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
1250 if (move)
1251 len += plen;
1252
1253 len += ubifs_auth_node_sz(c);
1254
1255 dent = kzalloc(len, GFP_NOFS);
1256 if (!dent)
1257 return -ENOMEM;
1258
1259
1260 err = make_reservation(c, BASEHD, len);
1261 if (err)
1262 goto out_free;
1263
1264
1265 dent->ch.node_type = UBIFS_DENT_NODE;
1266 dent_key_init_flash(c, &dent->key, new_dir->i_ino, new_nm);
1267 dent->inum = cpu_to_le64(old_inode->i_ino);
1268 dent->type = get_dent_type(old_inode->i_mode);
1269 dent->nlen = cpu_to_le16(fname_len(new_nm));
1270 memcpy(dent->name, fname_name(new_nm), fname_len(new_nm));
1271 dent->name[fname_len(new_nm)] = '\0';
1272 set_dent_cookie(c, dent);
1273 zero_dent_node_unused(dent);
1274 ubifs_prep_grp_node(c, dent, dlen1, 0);
1275 err = ubifs_node_calc_hash(c, dent, hash_dent1);
1276 if (err)
1277 goto out_release;
1278
1279 dent2 = (void *)dent + aligned_dlen1;
1280 dent2->ch.node_type = UBIFS_DENT_NODE;
1281 dent_key_init_flash(c, &dent2->key, old_dir->i_ino, old_nm);
1282
1283 if (whiteout) {
1284 dent2->inum = cpu_to_le64(whiteout->i_ino);
1285 dent2->type = get_dent_type(whiteout->i_mode);
1286 } else {
1287
1288 dent2->inum = 0;
1289 dent2->type = DT_UNKNOWN;
1290 }
1291 dent2->nlen = cpu_to_le16(fname_len(old_nm));
1292 memcpy(dent2->name, fname_name(old_nm), fname_len(old_nm));
1293 dent2->name[fname_len(old_nm)] = '\0';
1294 set_dent_cookie(c, dent2);
1295 zero_dent_node_unused(dent2);
1296 ubifs_prep_grp_node(c, dent2, dlen2, 0);
1297 err = ubifs_node_calc_hash(c, dent2, hash_dent2);
1298 if (err)
1299 goto out_release;
1300
1301 p = (void *)dent2 + aligned_dlen2;
1302 if (new_inode) {
1303 pack_inode(c, p, new_inode, 0);
1304 err = ubifs_node_calc_hash(c, p, hash_new_inode);
1305 if (err)
1306 goto out_release;
1307
1308 p += ALIGN(ilen, 8);
1309 }
1310
1311 if (!move) {
1312 pack_inode(c, p, old_dir, 1);
1313 err = ubifs_node_calc_hash(c, p, hash_old_dir);
1314 if (err)
1315 goto out_release;
1316 } else {
1317 pack_inode(c, p, old_dir, 0);
1318 err = ubifs_node_calc_hash(c, p, hash_old_dir);
1319 if (err)
1320 goto out_release;
1321
1322 p += ALIGN(plen, 8);
1323 pack_inode(c, p, new_dir, 1);
1324 err = ubifs_node_calc_hash(c, p, hash_new_dir);
1325 if (err)
1326 goto out_release;
1327 }
1328
1329 if (last_reference) {
1330 err = ubifs_add_orphan(c, new_inode->i_ino);
1331 if (err) {
1332 release_head(c, BASEHD);
1333 goto out_finish;
1334 }
1335 new_ui->del_cmtno = c->cmt_no;
1336 }
1337
1338 err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
1339 if (err)
1340 goto out_release;
1341 if (!sync) {
1342 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1343
1344 ubifs_wbuf_add_ino_nolock(wbuf, new_dir->i_ino);
1345 ubifs_wbuf_add_ino_nolock(wbuf, old_dir->i_ino);
1346 if (new_inode)
1347 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
1348 new_inode->i_ino);
1349 }
1350 release_head(c, BASEHD);
1351
1352 ubifs_add_auth_dirt(c, lnum);
1353
1354 dent_key_init(c, &key, new_dir->i_ino, new_nm);
1355 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, hash_dent1, new_nm);
1356 if (err)
1357 goto out_ro;
1358
1359 offs += aligned_dlen1;
1360 if (whiteout) {
1361 dent_key_init(c, &key, old_dir->i_ino, old_nm);
1362 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, hash_dent2, old_nm);
1363 if (err)
1364 goto out_ro;
1365
1366 ubifs_delete_orphan(c, whiteout->i_ino);
1367 } else {
1368 err = ubifs_add_dirt(c, lnum, dlen2);
1369 if (err)
1370 goto out_ro;
1371
1372 dent_key_init(c, &key, old_dir->i_ino, old_nm);
1373 err = ubifs_tnc_remove_nm(c, &key, old_nm);
1374 if (err)
1375 goto out_ro;
1376 }
1377
1378 offs += aligned_dlen2;
1379 if (new_inode) {
1380 ino_key_init(c, &key, new_inode->i_ino);
1381 err = ubifs_tnc_add(c, &key, lnum, offs, ilen, hash_new_inode);
1382 if (err)
1383 goto out_ro;
1384 offs += ALIGN(ilen, 8);
1385 }
1386
1387 ino_key_init(c, &key, old_dir->i_ino);
1388 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_old_dir);
1389 if (err)
1390 goto out_ro;
1391
1392 if (move) {
1393 offs += ALIGN(plen, 8);
1394 ino_key_init(c, &key, new_dir->i_ino);
1395 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_new_dir);
1396 if (err)
1397 goto out_ro;
1398 }
1399
1400 finish_reservation(c);
1401 if (new_inode) {
1402 mark_inode_clean(c, new_ui);
1403 spin_lock(&new_ui->ui_lock);
1404 new_ui->synced_i_size = new_ui->ui_size;
1405 spin_unlock(&new_ui->ui_lock);
1406 }
1407 mark_inode_clean(c, ubifs_inode(old_dir));
1408 if (move)
1409 mark_inode_clean(c, ubifs_inode(new_dir));
1410 kfree(dent);
1411 return 0;
1412
1413 out_release:
1414 release_head(c, BASEHD);
1415 out_ro:
1416 ubifs_ro_mode(c, err);
1417 if (last_reference)
1418 ubifs_delete_orphan(c, new_inode->i_ino);
1419 out_finish:
1420 finish_reservation(c);
1421 out_free:
1422 kfree(dent);
1423 return err;
1424 }
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437 static int truncate_data_node(const struct ubifs_info *c, const struct inode *inode,
1438 unsigned int block, struct ubifs_data_node *dn,
1439 int *new_len)
1440 {
1441 void *buf;
1442 int err, dlen, compr_type, out_len, old_dlen;
1443
1444 out_len = le32_to_cpu(dn->size);
1445 buf = kmalloc_array(out_len, WORST_COMPR_FACTOR, GFP_NOFS);
1446 if (!buf)
1447 return -ENOMEM;
1448
1449 dlen = old_dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1450 compr_type = le16_to_cpu(dn->compr_type);
1451
1452 if (ubifs_crypt_is_encrypted(inode)) {
1453 err = ubifs_decrypt(inode, dn, &dlen, block);
1454 if (err)
1455 goto out;
1456 }
1457
1458 if (compr_type == UBIFS_COMPR_NONE) {
1459 out_len = *new_len;
1460 } else {
1461 err = ubifs_decompress(c, &dn->data, dlen, buf, &out_len, compr_type);
1462 if (err)
1463 goto out;
1464
1465 ubifs_compress(c, buf, *new_len, &dn->data, &out_len, &compr_type);
1466 }
1467
1468 if (ubifs_crypt_is_encrypted(inode)) {
1469 err = ubifs_encrypt(inode, dn, out_len, &old_dlen, block);
1470 if (err)
1471 goto out;
1472
1473 out_len = old_dlen;
1474 } else {
1475 dn->compr_size = 0;
1476 }
1477
1478 ubifs_assert(c, out_len <= UBIFS_BLOCK_SIZE);
1479 dn->compr_type = cpu_to_le16(compr_type);
1480 dn->size = cpu_to_le32(*new_len);
1481 *new_len = UBIFS_DATA_NODE_SZ + out_len;
1482 err = 0;
1483 out:
1484 kfree(buf);
1485 return err;
1486 }
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503 int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
1504 loff_t old_size, loff_t new_size)
1505 {
1506 union ubifs_key key, to_key;
1507 struct ubifs_ino_node *ino;
1508 struct ubifs_trun_node *trun;
1509 struct ubifs_data_node *uninitialized_var(dn);
1510 int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
1511 struct ubifs_inode *ui = ubifs_inode(inode);
1512 ino_t inum = inode->i_ino;
1513 unsigned int blk;
1514 u8 hash_ino[UBIFS_HASH_ARR_SZ];
1515 u8 hash_dn[UBIFS_HASH_ARR_SZ];
1516
1517 dbg_jnl("ino %lu, size %lld -> %lld",
1518 (unsigned long)inum, old_size, new_size);
1519 ubifs_assert(c, !ui->data_len);
1520 ubifs_assert(c, S_ISREG(inode->i_mode));
1521 ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
1522
1523 sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
1524 UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
1525
1526 sz += ubifs_auth_node_sz(c);
1527
1528 ino = kmalloc(sz, GFP_NOFS);
1529 if (!ino)
1530 return -ENOMEM;
1531
1532 trun = (void *)ino + UBIFS_INO_NODE_SZ;
1533 trun->ch.node_type = UBIFS_TRUN_NODE;
1534 trun->inum = cpu_to_le32(inum);
1535 trun->old_size = cpu_to_le64(old_size);
1536 trun->new_size = cpu_to_le64(new_size);
1537 zero_trun_node_unused(trun);
1538
1539 dlen = new_size & (UBIFS_BLOCK_SIZE - 1);
1540 if (dlen) {
1541
1542 dn = (void *)trun + UBIFS_TRUN_NODE_SZ;
1543 blk = new_size >> UBIFS_BLOCK_SHIFT;
1544 data_key_init(c, &key, inum, blk);
1545 dbg_jnlk(&key, "last block key ");
1546 err = ubifs_tnc_lookup(c, &key, dn);
1547 if (err == -ENOENT)
1548 dlen = 0;
1549 else if (err)
1550 goto out_free;
1551 else {
1552 int dn_len = le32_to_cpu(dn->size);
1553
1554 if (dn_len <= 0 || dn_len > UBIFS_BLOCK_SIZE) {
1555 ubifs_err(c, "bad data node (block %u, inode %lu)",
1556 blk, inode->i_ino);
1557 ubifs_dump_node(c, dn);
1558 goto out_free;
1559 }
1560
1561 if (dn_len <= dlen)
1562 dlen = 0;
1563 else {
1564 err = truncate_data_node(c, inode, blk, dn, &dlen);
1565 if (err)
1566 goto out_free;
1567 }
1568 }
1569 }
1570
1571
1572 len = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ;
1573
1574 if (ubifs_authenticated(c))
1575 len += ALIGN(dlen, 8) + ubifs_auth_node_sz(c);
1576 else
1577 len += dlen;
1578
1579 err = make_reservation(c, BASEHD, len);
1580 if (err)
1581 goto out_free;
1582
1583 pack_inode(c, ino, inode, 0);
1584 err = ubifs_node_calc_hash(c, ino, hash_ino);
1585 if (err)
1586 goto out_release;
1587
1588 ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
1589 if (dlen) {
1590 ubifs_prep_grp_node(c, dn, dlen, 1);
1591 err = ubifs_node_calc_hash(c, dn, hash_dn);
1592 if (err)
1593 goto out_release;
1594 }
1595
1596 err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
1597 if (err)
1598 goto out_release;
1599 if (!sync)
1600 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
1601 release_head(c, BASEHD);
1602
1603 ubifs_add_auth_dirt(c, lnum);
1604
1605 if (dlen) {
1606 sz = offs + UBIFS_INO_NODE_SZ + UBIFS_TRUN_NODE_SZ;
1607 err = ubifs_tnc_add(c, &key, lnum, sz, dlen, hash_dn);
1608 if (err)
1609 goto out_ro;
1610 }
1611
1612 ino_key_init(c, &key, inum);
1613 err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ, hash_ino);
1614 if (err)
1615 goto out_ro;
1616
1617 err = ubifs_add_dirt(c, lnum, UBIFS_TRUN_NODE_SZ);
1618 if (err)
1619 goto out_ro;
1620
1621 bit = new_size & (UBIFS_BLOCK_SIZE - 1);
1622 blk = (new_size >> UBIFS_BLOCK_SHIFT) + (bit ? 1 : 0);
1623 data_key_init(c, &key, inum, blk);
1624
1625 bit = old_size & (UBIFS_BLOCK_SIZE - 1);
1626 blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0 : 1);
1627 data_key_init(c, &to_key, inum, blk);
1628
1629 err = ubifs_tnc_remove_range(c, &key, &to_key);
1630 if (err)
1631 goto out_ro;
1632
1633 finish_reservation(c);
1634 spin_lock(&ui->ui_lock);
1635 ui->synced_i_size = ui->ui_size;
1636 spin_unlock(&ui->ui_lock);
1637 mark_inode_clean(c, ui);
1638 kfree(ino);
1639 return 0;
1640
1641 out_release:
1642 release_head(c, BASEHD);
1643 out_ro:
1644 ubifs_ro_mode(c, err);
1645 finish_reservation(c);
1646 out_free:
1647 kfree(ino);
1648 return err;
1649 }
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664 int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
1665 const struct inode *inode,
1666 const struct fscrypt_name *nm)
1667 {
1668 int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen, write_len;
1669 struct ubifs_dent_node *xent;
1670 struct ubifs_ino_node *ino;
1671 union ubifs_key xent_key, key1, key2;
1672 int sync = IS_DIRSYNC(host);
1673 struct ubifs_inode *host_ui = ubifs_inode(host);
1674 u8 hash[UBIFS_HASH_ARR_SZ];
1675
1676 ubifs_assert(c, inode->i_nlink == 0);
1677 ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
1678
1679
1680
1681
1682
1683 xlen = UBIFS_DENT_NODE_SZ + fname_len(nm) + 1;
1684 aligned_xlen = ALIGN(xlen, 8);
1685 hlen = host_ui->data_len + UBIFS_INO_NODE_SZ;
1686 len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
1687
1688 write_len = len + ubifs_auth_node_sz(c);
1689
1690 xent = kzalloc(write_len, GFP_NOFS);
1691 if (!xent)
1692 return -ENOMEM;
1693
1694
1695 err = make_reservation(c, BASEHD, write_len);
1696 if (err) {
1697 kfree(xent);
1698 return err;
1699 }
1700
1701 xent->ch.node_type = UBIFS_XENT_NODE;
1702 xent_key_init(c, &xent_key, host->i_ino, nm);
1703 key_write(c, &xent_key, xent->key);
1704 xent->inum = 0;
1705 xent->type = get_dent_type(inode->i_mode);
1706 xent->nlen = cpu_to_le16(fname_len(nm));
1707 memcpy(xent->name, fname_name(nm), fname_len(nm));
1708 xent->name[fname_len(nm)] = '\0';
1709 zero_dent_node_unused(xent);
1710 ubifs_prep_grp_node(c, xent, xlen, 0);
1711
1712 ino = (void *)xent + aligned_xlen;
1713 pack_inode(c, ino, inode, 0);
1714 ino = (void *)ino + UBIFS_INO_NODE_SZ;
1715 pack_inode(c, ino, host, 1);
1716 err = ubifs_node_calc_hash(c, ino, hash);
1717 if (err)
1718 goto out_release;
1719
1720 err = write_head(c, BASEHD, xent, write_len, &lnum, &xent_offs, sync);
1721 if (!sync && !err)
1722 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
1723 release_head(c, BASEHD);
1724
1725 ubifs_add_auth_dirt(c, lnum);
1726 kfree(xent);
1727 if (err)
1728 goto out_ro;
1729
1730
1731 err = ubifs_tnc_remove_nm(c, &xent_key, nm);
1732 if (err)
1733 goto out_ro;
1734 err = ubifs_add_dirt(c, lnum, xlen);
1735 if (err)
1736 goto out_ro;
1737
1738
1739
1740
1741
1742 lowest_ino_key(c, &key1, inode->i_ino);
1743 highest_ino_key(c, &key2, inode->i_ino);
1744 err = ubifs_tnc_remove_range(c, &key1, &key2);
1745 if (err)
1746 goto out_ro;
1747 err = ubifs_add_dirt(c, lnum, UBIFS_INO_NODE_SZ);
1748 if (err)
1749 goto out_ro;
1750
1751
1752 ino_key_init(c, &key1, host->i_ino);
1753 err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen, hash);
1754 if (err)
1755 goto out_ro;
1756
1757 finish_reservation(c);
1758 spin_lock(&host_ui->ui_lock);
1759 host_ui->synced_i_size = host_ui->ui_size;
1760 spin_unlock(&host_ui->ui_lock);
1761 mark_inode_clean(c, host_ui);
1762 return 0;
1763
1764 out_release:
1765 kfree(xent);
1766 release_head(c, BASEHD);
1767 out_ro:
1768 ubifs_ro_mode(c, err);
1769 finish_reservation(c);
1770 return err;
1771 }
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786 int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
1787 const struct inode *host)
1788 {
1789 int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
1790 struct ubifs_inode *host_ui = ubifs_inode(host);
1791 struct ubifs_ino_node *ino;
1792 union ubifs_key key;
1793 int sync = IS_DIRSYNC(host);
1794 u8 hash_host[UBIFS_HASH_ARR_SZ];
1795 u8 hash[UBIFS_HASH_ARR_SZ];
1796
1797 dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1798 ubifs_assert(c, host->i_nlink > 0);
1799 ubifs_assert(c, inode->i_nlink > 0);
1800 ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
1801
1802 len1 = UBIFS_INO_NODE_SZ + host_ui->data_len;
1803 len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode)->data_len;
1804 aligned_len1 = ALIGN(len1, 8);
1805 aligned_len = aligned_len1 + ALIGN(len2, 8);
1806
1807 aligned_len += ubifs_auth_node_sz(c);
1808
1809 ino = kzalloc(aligned_len, GFP_NOFS);
1810 if (!ino)
1811 return -ENOMEM;
1812
1813
1814 err = make_reservation(c, BASEHD, aligned_len);
1815 if (err)
1816 goto out_free;
1817
1818 pack_inode(c, ino, host, 0);
1819 err = ubifs_node_calc_hash(c, ino, hash_host);
1820 if (err)
1821 goto out_release;
1822 pack_inode(c, (void *)ino + aligned_len1, inode, 1);
1823 err = ubifs_node_calc_hash(c, (void *)ino + aligned_len1, hash);
1824 if (err)
1825 goto out_release;
1826
1827 err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
1828 if (!sync && !err) {
1829 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1830
1831 ubifs_wbuf_add_ino_nolock(wbuf, host->i_ino);
1832 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
1833 }
1834 release_head(c, BASEHD);
1835 if (err)
1836 goto out_ro;
1837
1838 ubifs_add_auth_dirt(c, lnum);
1839
1840 ino_key_init(c, &key, host->i_ino);
1841 err = ubifs_tnc_add(c, &key, lnum, offs, len1, hash_host);
1842 if (err)
1843 goto out_ro;
1844
1845 ino_key_init(c, &key, inode->i_ino);
1846 err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2, hash);
1847 if (err)
1848 goto out_ro;
1849
1850 finish_reservation(c);
1851 spin_lock(&host_ui->ui_lock);
1852 host_ui->synced_i_size = host_ui->ui_size;
1853 spin_unlock(&host_ui->ui_lock);
1854 mark_inode_clean(c, host_ui);
1855 kfree(ino);
1856 return 0;
1857
1858 out_release:
1859 release_head(c, BASEHD);
1860 out_ro:
1861 ubifs_ro_mode(c, err);
1862 finish_reservation(c);
1863 out_free:
1864 kfree(ino);
1865 return err;
1866 }
1867