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
55static 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
66static inline void zero_dent_node_unused(struct ubifs_dent_node *dent)
67{
68 dent->padding1 = 0;
69}
70
71
72
73
74
75
76static inline void zero_trun_node_unused(struct ubifs_trun_node *trun)
77{
78 memset(trun->padding, 0, 12);
79}
80
81static 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
98static 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);
110again:
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
185out:
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
206out_unlock:
207 mutex_unlock(&wbuf->io_mutex);
208 return err;
209
210out_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
225static 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
268static 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
311static int make_reservation(struct ubifs_info *c, int jhead, int len)
312{
313 int err, cmt_retries = 0, nospc_retries = 0;
314
315again:
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
371out:
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
395static 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
407static void finish_reservation(struct ubifs_info *c)
408{
409 up_read(&c->commit_sem);
410}
411
412
413
414
415
416static 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
446static 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
496static 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
503static void set_dent_cookie(struct ubifs_info *c, struct ubifs_dent_node *dent)
504{
505 if (c->double_hash)
506 dent->cookie = (__force __le32) 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
538int 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, orphan_added = 0;
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 (fname_name(nm) == NULL)
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 orphan_added = 1;
634 }
635
636 err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
637 if (err)
638 goto out_release;
639 if (!sync) {
640 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
641
642 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
643 ubifs_wbuf_add_ino_nolock(wbuf, dir->i_ino);
644 }
645 release_head(c, BASEHD);
646 kfree(dent);
647 ubifs_add_auth_dirt(c, lnum);
648
649 if (deletion) {
650 if (fname_name(nm) == NULL)
651 err = ubifs_tnc_remove_dh(c, &dent_key, nm->minor_hash);
652 else
653 err = ubifs_tnc_remove_nm(c, &dent_key, nm);
654 if (err)
655 goto out_ro;
656 err = ubifs_add_dirt(c, lnum, dlen);
657 } else
658 err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen,
659 hash_dent, nm);
660 if (err)
661 goto out_ro;
662
663
664
665
666
667
668
669 ino_key_init(c, &ino_key, inode->i_ino);
670 ino_offs = dent_offs + aligned_dlen;
671 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen, hash_ino);
672 if (err)
673 goto out_ro;
674
675 ino_key_init(c, &ino_key, dir->i_ino);
676 ino_offs += aligned_ilen;
677 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs,
678 UBIFS_INO_NODE_SZ + host_ui->data_len, hash_ino_host);
679 if (err)
680 goto out_ro;
681
682 finish_reservation(c);
683 spin_lock(&ui->ui_lock);
684 ui->synced_i_size = ui->ui_size;
685 spin_unlock(&ui->ui_lock);
686 if (xent) {
687 spin_lock(&host_ui->ui_lock);
688 host_ui->synced_i_size = host_ui->ui_size;
689 spin_unlock(&host_ui->ui_lock);
690 }
691 mark_inode_clean(c, ui);
692 mark_inode_clean(c, host_ui);
693 return 0;
694
695out_finish:
696 finish_reservation(c);
697out_free:
698 kfree(dent);
699 return err;
700
701out_release:
702 release_head(c, BASEHD);
703 kfree(dent);
704out_ro:
705 ubifs_ro_mode(c, err);
706 if (orphan_added)
707 ubifs_delete_orphan(c, inode->i_ino);
708 finish_reservation(c);
709 return err;
710}
711
712
713
714
715
716
717
718
719
720
721
722
723int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
724 const union ubifs_key *key, const void *buf, int len)
725{
726 struct ubifs_data_node *data;
727 int err, lnum, offs, compr_type, out_len, compr_len, auth_len;
728 int dlen = COMPRESSED_DATA_NODE_BUF_SZ, allocated = 1;
729 int write_len;
730 struct ubifs_inode *ui = ubifs_inode(inode);
731 bool encrypted = IS_ENCRYPTED(inode);
732 u8 hash[UBIFS_HASH_ARR_SZ];
733
734 dbg_jnlk(key, "ino %lu, blk %u, len %d, key ",
735 (unsigned long)key_inum(c, key), key_block(c, key), len);
736 ubifs_assert(c, len <= UBIFS_BLOCK_SIZE);
737
738 if (encrypted)
739 dlen += UBIFS_CIPHER_BLOCK_SIZE;
740
741 auth_len = ubifs_auth_node_sz(c);
742
743 data = kmalloc(dlen + auth_len, GFP_NOFS | __GFP_NOWARN);
744 if (!data) {
745
746
747
748
749
750
751
752 allocated = 0;
753 mutex_lock(&c->write_reserve_mutex);
754 data = c->write_reserve_buf;
755 }
756
757 data->ch.node_type = UBIFS_DATA_NODE;
758 key_write(c, key, &data->key);
759 data->size = cpu_to_le32(len);
760
761 if (!(ui->flags & UBIFS_COMPR_FL))
762
763 compr_type = UBIFS_COMPR_NONE;
764 else
765 compr_type = ui->compr_type;
766
767 out_len = compr_len = dlen - UBIFS_DATA_NODE_SZ;
768 ubifs_compress(c, buf, len, &data->data, &compr_len, &compr_type);
769 ubifs_assert(c, compr_len <= UBIFS_BLOCK_SIZE);
770
771 if (encrypted) {
772 err = ubifs_encrypt(inode, data, compr_len, &out_len, key_block(c, key));
773 if (err)
774 goto out_free;
775
776 } else {
777 data->compr_size = 0;
778 out_len = compr_len;
779 }
780
781 dlen = UBIFS_DATA_NODE_SZ + out_len;
782 if (ubifs_authenticated(c))
783 write_len = ALIGN(dlen, 8) + auth_len;
784 else
785 write_len = dlen;
786
787 data->compr_type = cpu_to_le16(compr_type);
788
789
790 err = make_reservation(c, DATAHD, write_len);
791 if (err)
792 goto out_free;
793
794 ubifs_prepare_node(c, data, dlen, 0);
795 err = write_head(c, DATAHD, data, write_len, &lnum, &offs, 0);
796 if (err)
797 goto out_release;
798
799 err = ubifs_node_calc_hash(c, data, hash);
800 if (err)
801 goto out_release;
802
803 ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf, key_inum(c, key));
804 release_head(c, DATAHD);
805
806 ubifs_add_auth_dirt(c, lnum);
807
808 err = ubifs_tnc_add(c, key, lnum, offs, dlen, hash);
809 if (err)
810 goto out_ro;
811
812 finish_reservation(c);
813 if (!allocated)
814 mutex_unlock(&c->write_reserve_mutex);
815 else
816 kfree(data);
817 return 0;
818
819out_release:
820 release_head(c, DATAHD);
821out_ro:
822 ubifs_ro_mode(c, err);
823 finish_reservation(c);
824out_free:
825 if (!allocated)
826 mutex_unlock(&c->write_reserve_mutex);
827 else
828 kfree(data);
829 return err;
830}
831
832
833
834
835
836
837
838
839
840
841int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode)
842{
843 int err, lnum, offs;
844 struct ubifs_ino_node *ino, *ino_start;
845 struct ubifs_inode *ui = ubifs_inode(inode);
846 int sync = 0, write_len = 0, ilen = UBIFS_INO_NODE_SZ;
847 int last_reference = !inode->i_nlink;
848 int kill_xattrs = ui->xattr_cnt && last_reference;
849 u8 hash[UBIFS_HASH_ARR_SZ];
850
851 dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
852
853
854
855
856
857 if (!last_reference) {
858 ilen += ui->data_len;
859 sync = IS_SYNC(inode);
860 } else if (kill_xattrs) {
861 write_len += UBIFS_INO_NODE_SZ * ui->xattr_cnt;
862 }
863
864 if (ubifs_authenticated(c))
865 write_len += ALIGN(ilen, 8) + ubifs_auth_node_sz(c);
866 else
867 write_len += ilen;
868
869 ino_start = ino = kmalloc(write_len, GFP_NOFS);
870 if (!ino)
871 return -ENOMEM;
872
873
874 err = make_reservation(c, BASEHD, write_len);
875 if (err)
876 goto out_free;
877
878 if (kill_xattrs) {
879 union ubifs_key key;
880 struct fscrypt_name nm = {0};
881 struct inode *xino;
882 struct ubifs_dent_node *xent, *pxent = NULL;
883
884 if (ui->xattr_cnt > ubifs_xattr_max_cnt(c)) {
885 err = -EPERM;
886 ubifs_err(c, "Cannot delete inode, it has too much xattrs!");
887 goto out_release;
888 }
889
890 lowest_xent_key(c, &key, inode->i_ino);
891 while (1) {
892 xent = ubifs_tnc_next_ent(c, &key, &nm);
893 if (IS_ERR(xent)) {
894 err = PTR_ERR(xent);
895 if (err == -ENOENT)
896 break;
897
898 kfree(pxent);
899 goto out_release;
900 }
901
902 fname_name(&nm) = xent->name;
903 fname_len(&nm) = le16_to_cpu(xent->nlen);
904
905 xino = ubifs_iget(c->vfs_sb, le64_to_cpu(xent->inum));
906 if (IS_ERR(xino)) {
907 err = PTR_ERR(xino);
908 ubifs_err(c, "dead directory entry '%s', error %d",
909 xent->name, err);
910 ubifs_ro_mode(c, err);
911 kfree(pxent);
912 kfree(xent);
913 goto out_release;
914 }
915 ubifs_assert(c, ubifs_inode(xino)->xattr);
916
917 clear_nlink(xino);
918 pack_inode(c, ino, xino, 0);
919 ino = (void *)ino + UBIFS_INO_NODE_SZ;
920 iput(xino);
921
922 kfree(pxent);
923 pxent = xent;
924 key_read(c, &xent->key, &key);
925 }
926 kfree(pxent);
927 }
928
929 pack_inode(c, ino, inode, 1);
930 err = ubifs_node_calc_hash(c, ino, hash);
931 if (err)
932 goto out_release;
933
934 err = write_head(c, BASEHD, ino_start, write_len, &lnum, &offs, sync);
935 if (err)
936 goto out_release;
937 if (!sync)
938 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
939 inode->i_ino);
940 release_head(c, BASEHD);
941
942 if (last_reference) {
943 err = ubifs_tnc_remove_ino(c, inode->i_ino);
944 if (err)
945 goto out_ro;
946 ubifs_delete_orphan(c, inode->i_ino);
947 err = ubifs_add_dirt(c, lnum, write_len);
948 } else {
949 union ubifs_key key;
950
951 ubifs_add_auth_dirt(c, lnum);
952
953 ino_key_init(c, &key, inode->i_ino);
954 err = ubifs_tnc_add(c, &key, lnum, offs, ilen, hash);
955 }
956 if (err)
957 goto out_ro;
958
959 finish_reservation(c);
960 spin_lock(&ui->ui_lock);
961 ui->synced_i_size = ui->ui_size;
962 spin_unlock(&ui->ui_lock);
963 kfree(ino_start);
964 return 0;
965
966out_release:
967 release_head(c, BASEHD);
968out_ro:
969 ubifs_ro_mode(c, err);
970 finish_reservation(c);
971out_free:
972 kfree(ino_start);
973 return err;
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
1001
1002
1003
1004
1005int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode)
1006{
1007 int err;
1008 struct ubifs_inode *ui = ubifs_inode(inode);
1009
1010 ubifs_assert(c, inode->i_nlink == 0);
1011
1012 if (ui->xattr_cnt || ui->del_cmtno != c->cmt_no)
1013
1014 return ubifs_jnl_write_inode(c, inode);
1015
1016 down_read(&c->commit_sem);
1017
1018
1019
1020
1021 if (ui->del_cmtno != c->cmt_no) {
1022 up_read(&c->commit_sem);
1023 return ubifs_jnl_write_inode(c, inode);
1024 }
1025
1026 err = ubifs_tnc_remove_ino(c, inode->i_ino);
1027 if (err)
1028 ubifs_ro_mode(c, err);
1029 else
1030 ubifs_delete_orphan(c, inode->i_ino);
1031 up_read(&c->commit_sem);
1032 return err;
1033}
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051int ubifs_jnl_xrename(struct ubifs_info *c, const struct inode *fst_dir,
1052 const struct inode *fst_inode,
1053 const struct fscrypt_name *fst_nm,
1054 const struct inode *snd_dir,
1055 const struct inode *snd_inode,
1056 const struct fscrypt_name *snd_nm, int sync)
1057{
1058 union ubifs_key key;
1059 struct ubifs_dent_node *dent1, *dent2;
1060 int err, dlen1, dlen2, lnum, offs, len, plen = UBIFS_INO_NODE_SZ;
1061 int aligned_dlen1, aligned_dlen2;
1062 int twoparents = (fst_dir != snd_dir);
1063 void *p;
1064 u8 hash_dent1[UBIFS_HASH_ARR_SZ];
1065 u8 hash_dent2[UBIFS_HASH_ARR_SZ];
1066 u8 hash_p1[UBIFS_HASH_ARR_SZ];
1067 u8 hash_p2[UBIFS_HASH_ARR_SZ];
1068
1069 ubifs_assert(c, ubifs_inode(fst_dir)->data_len == 0);
1070 ubifs_assert(c, ubifs_inode(snd_dir)->data_len == 0);
1071 ubifs_assert(c, mutex_is_locked(&ubifs_inode(fst_dir)->ui_mutex));
1072 ubifs_assert(c, mutex_is_locked(&ubifs_inode(snd_dir)->ui_mutex));
1073
1074 dlen1 = UBIFS_DENT_NODE_SZ + fname_len(snd_nm) + 1;
1075 dlen2 = UBIFS_DENT_NODE_SZ + fname_len(fst_nm) + 1;
1076 aligned_dlen1 = ALIGN(dlen1, 8);
1077 aligned_dlen2 = ALIGN(dlen2, 8);
1078
1079 len = aligned_dlen1 + aligned_dlen2 + ALIGN(plen, 8);
1080 if (twoparents)
1081 len += plen;
1082
1083 len += ubifs_auth_node_sz(c);
1084
1085 dent1 = kzalloc(len, GFP_NOFS);
1086 if (!dent1)
1087 return -ENOMEM;
1088
1089
1090 err = make_reservation(c, BASEHD, len);
1091 if (err)
1092 goto out_free;
1093
1094
1095 dent1->ch.node_type = UBIFS_DENT_NODE;
1096 dent_key_init_flash(c, &dent1->key, snd_dir->i_ino, snd_nm);
1097 dent1->inum = cpu_to_le64(fst_inode->i_ino);
1098 dent1->type = get_dent_type(fst_inode->i_mode);
1099 dent1->nlen = cpu_to_le16(fname_len(snd_nm));
1100 memcpy(dent1->name, fname_name(snd_nm), fname_len(snd_nm));
1101 dent1->name[fname_len(snd_nm)] = '\0';
1102 set_dent_cookie(c, dent1);
1103 zero_dent_node_unused(dent1);
1104 ubifs_prep_grp_node(c, dent1, dlen1, 0);
1105 err = ubifs_node_calc_hash(c, dent1, hash_dent1);
1106 if (err)
1107 goto out_release;
1108
1109
1110 dent2 = (void *)dent1 + aligned_dlen1;
1111 dent2->ch.node_type = UBIFS_DENT_NODE;
1112 dent_key_init_flash(c, &dent2->key, fst_dir->i_ino, fst_nm);
1113 dent2->inum = cpu_to_le64(snd_inode->i_ino);
1114 dent2->type = get_dent_type(snd_inode->i_mode);
1115 dent2->nlen = cpu_to_le16(fname_len(fst_nm));
1116 memcpy(dent2->name, fname_name(fst_nm), fname_len(fst_nm));
1117 dent2->name[fname_len(fst_nm)] = '\0';
1118 set_dent_cookie(c, dent2);
1119 zero_dent_node_unused(dent2);
1120 ubifs_prep_grp_node(c, dent2, dlen2, 0);
1121 err = ubifs_node_calc_hash(c, dent2, hash_dent2);
1122 if (err)
1123 goto out_release;
1124
1125 p = (void *)dent2 + aligned_dlen2;
1126 if (!twoparents) {
1127 pack_inode(c, p, fst_dir, 1);
1128 err = ubifs_node_calc_hash(c, p, hash_p1);
1129 if (err)
1130 goto out_release;
1131 } else {
1132 pack_inode(c, p, fst_dir, 0);
1133 err = ubifs_node_calc_hash(c, p, hash_p1);
1134 if (err)
1135 goto out_release;
1136 p += ALIGN(plen, 8);
1137 pack_inode(c, p, snd_dir, 1);
1138 err = ubifs_node_calc_hash(c, p, hash_p2);
1139 if (err)
1140 goto out_release;
1141 }
1142
1143 err = write_head(c, BASEHD, dent1, len, &lnum, &offs, sync);
1144 if (err)
1145 goto out_release;
1146 if (!sync) {
1147 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1148
1149 ubifs_wbuf_add_ino_nolock(wbuf, fst_dir->i_ino);
1150 ubifs_wbuf_add_ino_nolock(wbuf, snd_dir->i_ino);
1151 }
1152 release_head(c, BASEHD);
1153
1154 ubifs_add_auth_dirt(c, lnum);
1155
1156 dent_key_init(c, &key, snd_dir->i_ino, snd_nm);
1157 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, hash_dent1, snd_nm);
1158 if (err)
1159 goto out_ro;
1160
1161 offs += aligned_dlen1;
1162 dent_key_init(c, &key, fst_dir->i_ino, fst_nm);
1163 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, hash_dent2, fst_nm);
1164 if (err)
1165 goto out_ro;
1166
1167 offs += aligned_dlen2;
1168
1169 ino_key_init(c, &key, fst_dir->i_ino);
1170 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_p1);
1171 if (err)
1172 goto out_ro;
1173
1174 if (twoparents) {
1175 offs += ALIGN(plen, 8);
1176 ino_key_init(c, &key, snd_dir->i_ino);
1177 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_p2);
1178 if (err)
1179 goto out_ro;
1180 }
1181
1182 finish_reservation(c);
1183
1184 mark_inode_clean(c, ubifs_inode(fst_dir));
1185 if (twoparents)
1186 mark_inode_clean(c, ubifs_inode(snd_dir));
1187 kfree(dent1);
1188 return 0;
1189
1190out_release:
1191 release_head(c, BASEHD);
1192out_ro:
1193 ubifs_ro_mode(c, err);
1194 finish_reservation(c);
1195out_free:
1196 kfree(dent1);
1197 return err;
1198}
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
1215 const struct inode *old_inode,
1216 const struct fscrypt_name *old_nm,
1217 const struct inode *new_dir,
1218 const struct inode *new_inode,
1219 const struct fscrypt_name *new_nm,
1220 const struct inode *whiteout, int sync)
1221{
1222 void *p;
1223 union ubifs_key key;
1224 struct ubifs_dent_node *dent, *dent2;
1225 int err, dlen1, dlen2, ilen, lnum, offs, len, orphan_added = 0;
1226 int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
1227 int last_reference = !!(new_inode && new_inode->i_nlink == 0);
1228 int move = (old_dir != new_dir);
1229 struct ubifs_inode *new_ui;
1230 u8 hash_old_dir[UBIFS_HASH_ARR_SZ];
1231 u8 hash_new_dir[UBIFS_HASH_ARR_SZ];
1232 u8 hash_new_inode[UBIFS_HASH_ARR_SZ];
1233 u8 hash_dent1[UBIFS_HASH_ARR_SZ];
1234 u8 hash_dent2[UBIFS_HASH_ARR_SZ];
1235
1236 ubifs_assert(c, ubifs_inode(old_dir)->data_len == 0);
1237 ubifs_assert(c, ubifs_inode(new_dir)->data_len == 0);
1238 ubifs_assert(c, mutex_is_locked(&ubifs_inode(old_dir)->ui_mutex));
1239 ubifs_assert(c, mutex_is_locked(&ubifs_inode(new_dir)->ui_mutex));
1240
1241 dlen1 = UBIFS_DENT_NODE_SZ + fname_len(new_nm) + 1;
1242 dlen2 = UBIFS_DENT_NODE_SZ + fname_len(old_nm) + 1;
1243 if (new_inode) {
1244 new_ui = ubifs_inode(new_inode);
1245 ubifs_assert(c, mutex_is_locked(&new_ui->ui_mutex));
1246 ilen = UBIFS_INO_NODE_SZ;
1247 if (!last_reference)
1248 ilen += new_ui->data_len;
1249 } else
1250 ilen = 0;
1251
1252 aligned_dlen1 = ALIGN(dlen1, 8);
1253 aligned_dlen2 = ALIGN(dlen2, 8);
1254 len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
1255 if (move)
1256 len += plen;
1257
1258 len += ubifs_auth_node_sz(c);
1259
1260 dent = kzalloc(len, GFP_NOFS);
1261 if (!dent)
1262 return -ENOMEM;
1263
1264
1265 err = make_reservation(c, BASEHD, len);
1266 if (err)
1267 goto out_free;
1268
1269
1270 dent->ch.node_type = UBIFS_DENT_NODE;
1271 dent_key_init_flash(c, &dent->key, new_dir->i_ino, new_nm);
1272 dent->inum = cpu_to_le64(old_inode->i_ino);
1273 dent->type = get_dent_type(old_inode->i_mode);
1274 dent->nlen = cpu_to_le16(fname_len(new_nm));
1275 memcpy(dent->name, fname_name(new_nm), fname_len(new_nm));
1276 dent->name[fname_len(new_nm)] = '\0';
1277 set_dent_cookie(c, dent);
1278 zero_dent_node_unused(dent);
1279 ubifs_prep_grp_node(c, dent, dlen1, 0);
1280 err = ubifs_node_calc_hash(c, dent, hash_dent1);
1281 if (err)
1282 goto out_release;
1283
1284 dent2 = (void *)dent + aligned_dlen1;
1285 dent2->ch.node_type = UBIFS_DENT_NODE;
1286 dent_key_init_flash(c, &dent2->key, old_dir->i_ino, old_nm);
1287
1288 if (whiteout) {
1289 dent2->inum = cpu_to_le64(whiteout->i_ino);
1290 dent2->type = get_dent_type(whiteout->i_mode);
1291 } else {
1292
1293 dent2->inum = 0;
1294 dent2->type = DT_UNKNOWN;
1295 }
1296 dent2->nlen = cpu_to_le16(fname_len(old_nm));
1297 memcpy(dent2->name, fname_name(old_nm), fname_len(old_nm));
1298 dent2->name[fname_len(old_nm)] = '\0';
1299 set_dent_cookie(c, dent2);
1300 zero_dent_node_unused(dent2);
1301 ubifs_prep_grp_node(c, dent2, dlen2, 0);
1302 err = ubifs_node_calc_hash(c, dent2, hash_dent2);
1303 if (err)
1304 goto out_release;
1305
1306 p = (void *)dent2 + aligned_dlen2;
1307 if (new_inode) {
1308 pack_inode(c, p, new_inode, 0);
1309 err = ubifs_node_calc_hash(c, p, hash_new_inode);
1310 if (err)
1311 goto out_release;
1312
1313 p += ALIGN(ilen, 8);
1314 }
1315
1316 if (!move) {
1317 pack_inode(c, p, old_dir, 1);
1318 err = ubifs_node_calc_hash(c, p, hash_old_dir);
1319 if (err)
1320 goto out_release;
1321 } else {
1322 pack_inode(c, p, old_dir, 0);
1323 err = ubifs_node_calc_hash(c, p, hash_old_dir);
1324 if (err)
1325 goto out_release;
1326
1327 p += ALIGN(plen, 8);
1328 pack_inode(c, p, new_dir, 1);
1329 err = ubifs_node_calc_hash(c, p, hash_new_dir);
1330 if (err)
1331 goto out_release;
1332 }
1333
1334 if (last_reference) {
1335 err = ubifs_add_orphan(c, new_inode->i_ino);
1336 if (err) {
1337 release_head(c, BASEHD);
1338 goto out_finish;
1339 }
1340 new_ui->del_cmtno = c->cmt_no;
1341 orphan_added = 1;
1342 }
1343
1344 err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
1345 if (err)
1346 goto out_release;
1347 if (!sync) {
1348 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1349
1350 ubifs_wbuf_add_ino_nolock(wbuf, new_dir->i_ino);
1351 ubifs_wbuf_add_ino_nolock(wbuf, old_dir->i_ino);
1352 if (new_inode)
1353 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
1354 new_inode->i_ino);
1355 }
1356 release_head(c, BASEHD);
1357
1358 ubifs_add_auth_dirt(c, lnum);
1359
1360 dent_key_init(c, &key, new_dir->i_ino, new_nm);
1361 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, hash_dent1, new_nm);
1362 if (err)
1363 goto out_ro;
1364
1365 offs += aligned_dlen1;
1366 if (whiteout) {
1367 dent_key_init(c, &key, old_dir->i_ino, old_nm);
1368 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen2, hash_dent2, old_nm);
1369 if (err)
1370 goto out_ro;
1371
1372 ubifs_delete_orphan(c, whiteout->i_ino);
1373 } else {
1374 err = ubifs_add_dirt(c, lnum, dlen2);
1375 if (err)
1376 goto out_ro;
1377
1378 dent_key_init(c, &key, old_dir->i_ino, old_nm);
1379 err = ubifs_tnc_remove_nm(c, &key, old_nm);
1380 if (err)
1381 goto out_ro;
1382 }
1383
1384 offs += aligned_dlen2;
1385 if (new_inode) {
1386 ino_key_init(c, &key, new_inode->i_ino);
1387 err = ubifs_tnc_add(c, &key, lnum, offs, ilen, hash_new_inode);
1388 if (err)
1389 goto out_ro;
1390 offs += ALIGN(ilen, 8);
1391 }
1392
1393 ino_key_init(c, &key, old_dir->i_ino);
1394 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_old_dir);
1395 if (err)
1396 goto out_ro;
1397
1398 if (move) {
1399 offs += ALIGN(plen, 8);
1400 ino_key_init(c, &key, new_dir->i_ino);
1401 err = ubifs_tnc_add(c, &key, lnum, offs, plen, hash_new_dir);
1402 if (err)
1403 goto out_ro;
1404 }
1405
1406 finish_reservation(c);
1407 if (new_inode) {
1408 mark_inode_clean(c, new_ui);
1409 spin_lock(&new_ui->ui_lock);
1410 new_ui->synced_i_size = new_ui->ui_size;
1411 spin_unlock(&new_ui->ui_lock);
1412 }
1413 mark_inode_clean(c, ubifs_inode(old_dir));
1414 if (move)
1415 mark_inode_clean(c, ubifs_inode(new_dir));
1416 kfree(dent);
1417 return 0;
1418
1419out_release:
1420 release_head(c, BASEHD);
1421out_ro:
1422 ubifs_ro_mode(c, err);
1423 if (orphan_added)
1424 ubifs_delete_orphan(c, new_inode->i_ino);
1425out_finish:
1426 finish_reservation(c);
1427out_free:
1428 kfree(dent);
1429 return err;
1430}
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443static int truncate_data_node(const struct ubifs_info *c, const struct inode *inode,
1444 unsigned int block, struct ubifs_data_node *dn,
1445 int *new_len)
1446{
1447 void *buf;
1448 int err, dlen, compr_type, out_len, old_dlen;
1449
1450 out_len = le32_to_cpu(dn->size);
1451 buf = kmalloc_array(out_len, WORST_COMPR_FACTOR, GFP_NOFS);
1452 if (!buf)
1453 return -ENOMEM;
1454
1455 dlen = old_dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1456 compr_type = le16_to_cpu(dn->compr_type);
1457
1458 if (IS_ENCRYPTED(inode)) {
1459 err = ubifs_decrypt(inode, dn, &dlen, block);
1460 if (err)
1461 goto out;
1462 }
1463
1464 if (compr_type == UBIFS_COMPR_NONE) {
1465 out_len = *new_len;
1466 } else {
1467 err = ubifs_decompress(c, &dn->data, dlen, buf, &out_len, compr_type);
1468 if (err)
1469 goto out;
1470
1471 ubifs_compress(c, buf, *new_len, &dn->data, &out_len, &compr_type);
1472 }
1473
1474 if (IS_ENCRYPTED(inode)) {
1475 err = ubifs_encrypt(inode, dn, out_len, &old_dlen, block);
1476 if (err)
1477 goto out;
1478
1479 out_len = old_dlen;
1480 } else {
1481 dn->compr_size = 0;
1482 }
1483
1484 ubifs_assert(c, out_len <= UBIFS_BLOCK_SIZE);
1485 dn->compr_type = cpu_to_le16(compr_type);
1486 dn->size = cpu_to_le32(*new_len);
1487 *new_len = UBIFS_DATA_NODE_SZ + out_len;
1488 err = 0;
1489out:
1490 kfree(buf);
1491 return err;
1492}
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
1510 loff_t old_size, loff_t new_size)
1511{
1512 union ubifs_key key, to_key;
1513 struct ubifs_ino_node *ino;
1514 struct ubifs_trun_node *trun;
1515 struct ubifs_data_node *dn;
1516 int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
1517 struct ubifs_inode *ui = ubifs_inode(inode);
1518 ino_t inum = inode->i_ino;
1519 unsigned int blk;
1520 u8 hash_ino[UBIFS_HASH_ARR_SZ];
1521 u8 hash_dn[UBIFS_HASH_ARR_SZ];
1522
1523 dbg_jnl("ino %lu, size %lld -> %lld",
1524 (unsigned long)inum, old_size, new_size);
1525 ubifs_assert(c, !ui->data_len);
1526 ubifs_assert(c, S_ISREG(inode->i_mode));
1527 ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
1528
1529 sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
1530 UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
1531
1532 sz += ubifs_auth_node_sz(c);
1533
1534 ino = kmalloc(sz, GFP_NOFS);
1535 if (!ino)
1536 return -ENOMEM;
1537
1538 trun = (void *)ino + UBIFS_INO_NODE_SZ;
1539 trun->ch.node_type = UBIFS_TRUN_NODE;
1540 trun->inum = cpu_to_le32(inum);
1541 trun->old_size = cpu_to_le64(old_size);
1542 trun->new_size = cpu_to_le64(new_size);
1543 zero_trun_node_unused(trun);
1544
1545 dlen = new_size & (UBIFS_BLOCK_SIZE - 1);
1546 if (dlen) {
1547
1548 dn = (void *)trun + UBIFS_TRUN_NODE_SZ;
1549 blk = new_size >> UBIFS_BLOCK_SHIFT;
1550 data_key_init(c, &key, inum, blk);
1551 dbg_jnlk(&key, "last block key ");
1552 err = ubifs_tnc_lookup(c, &key, dn);
1553 if (err == -ENOENT)
1554 dlen = 0;
1555 else if (err)
1556 goto out_free;
1557 else {
1558 int dn_len = le32_to_cpu(dn->size);
1559
1560 if (dn_len <= 0 || dn_len > UBIFS_BLOCK_SIZE) {
1561 ubifs_err(c, "bad data node (block %u, inode %lu)",
1562 blk, inode->i_ino);
1563 ubifs_dump_node(c, dn, sz - UBIFS_INO_NODE_SZ -
1564 UBIFS_TRUN_NODE_SZ);
1565 goto out_free;
1566 }
1567
1568 if (dn_len <= dlen)
1569 dlen = 0;
1570 else {
1571 err = truncate_data_node(c, inode, blk, dn, &dlen);
1572 if (err)
1573 goto out_free;
1574 }
1575 }
1576 }
1577
1578
1579 len = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ;
1580
1581 if (ubifs_authenticated(c))
1582 len += ALIGN(dlen, 8) + ubifs_auth_node_sz(c);
1583 else
1584 len += dlen;
1585
1586 err = make_reservation(c, BASEHD, len);
1587 if (err)
1588 goto out_free;
1589
1590 pack_inode(c, ino, inode, 0);
1591 err = ubifs_node_calc_hash(c, ino, hash_ino);
1592 if (err)
1593 goto out_release;
1594
1595 ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
1596 if (dlen) {
1597 ubifs_prep_grp_node(c, dn, dlen, 1);
1598 err = ubifs_node_calc_hash(c, dn, hash_dn);
1599 if (err)
1600 goto out_release;
1601 }
1602
1603 err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
1604 if (err)
1605 goto out_release;
1606 if (!sync)
1607 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
1608 release_head(c, BASEHD);
1609
1610 ubifs_add_auth_dirt(c, lnum);
1611
1612 if (dlen) {
1613 sz = offs + UBIFS_INO_NODE_SZ + UBIFS_TRUN_NODE_SZ;
1614 err = ubifs_tnc_add(c, &key, lnum, sz, dlen, hash_dn);
1615 if (err)
1616 goto out_ro;
1617 }
1618
1619 ino_key_init(c, &key, inum);
1620 err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ, hash_ino);
1621 if (err)
1622 goto out_ro;
1623
1624 err = ubifs_add_dirt(c, lnum, UBIFS_TRUN_NODE_SZ);
1625 if (err)
1626 goto out_ro;
1627
1628 bit = new_size & (UBIFS_BLOCK_SIZE - 1);
1629 blk = (new_size >> UBIFS_BLOCK_SHIFT) + (bit ? 1 : 0);
1630 data_key_init(c, &key, inum, blk);
1631
1632 bit = old_size & (UBIFS_BLOCK_SIZE - 1);
1633 blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0 : 1);
1634 data_key_init(c, &to_key, inum, blk);
1635
1636 err = ubifs_tnc_remove_range(c, &key, &to_key);
1637 if (err)
1638 goto out_ro;
1639
1640 finish_reservation(c);
1641 spin_lock(&ui->ui_lock);
1642 ui->synced_i_size = ui->ui_size;
1643 spin_unlock(&ui->ui_lock);
1644 mark_inode_clean(c, ui);
1645 kfree(ino);
1646 return 0;
1647
1648out_release:
1649 release_head(c, BASEHD);
1650out_ro:
1651 ubifs_ro_mode(c, err);
1652 finish_reservation(c);
1653out_free:
1654 kfree(ino);
1655 return err;
1656}
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
1672 const struct inode *inode,
1673 const struct fscrypt_name *nm)
1674{
1675 int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen, write_len;
1676 struct ubifs_dent_node *xent;
1677 struct ubifs_ino_node *ino;
1678 union ubifs_key xent_key, key1, key2;
1679 int sync = IS_DIRSYNC(host);
1680 struct ubifs_inode *host_ui = ubifs_inode(host);
1681 u8 hash[UBIFS_HASH_ARR_SZ];
1682
1683 ubifs_assert(c, inode->i_nlink == 0);
1684 ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
1685
1686
1687
1688
1689
1690 xlen = UBIFS_DENT_NODE_SZ + fname_len(nm) + 1;
1691 aligned_xlen = ALIGN(xlen, 8);
1692 hlen = host_ui->data_len + UBIFS_INO_NODE_SZ;
1693 len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
1694
1695 write_len = len + ubifs_auth_node_sz(c);
1696
1697 xent = kzalloc(write_len, GFP_NOFS);
1698 if (!xent)
1699 return -ENOMEM;
1700
1701
1702 err = make_reservation(c, BASEHD, write_len);
1703 if (err) {
1704 kfree(xent);
1705 return err;
1706 }
1707
1708 xent->ch.node_type = UBIFS_XENT_NODE;
1709 xent_key_init(c, &xent_key, host->i_ino, nm);
1710 key_write(c, &xent_key, xent->key);
1711 xent->inum = 0;
1712 xent->type = get_dent_type(inode->i_mode);
1713 xent->nlen = cpu_to_le16(fname_len(nm));
1714 memcpy(xent->name, fname_name(nm), fname_len(nm));
1715 xent->name[fname_len(nm)] = '\0';
1716 zero_dent_node_unused(xent);
1717 ubifs_prep_grp_node(c, xent, xlen, 0);
1718
1719 ino = (void *)xent + aligned_xlen;
1720 pack_inode(c, ino, inode, 0);
1721 ino = (void *)ino + UBIFS_INO_NODE_SZ;
1722 pack_inode(c, ino, host, 1);
1723 err = ubifs_node_calc_hash(c, ino, hash);
1724 if (err)
1725 goto out_release;
1726
1727 err = write_head(c, BASEHD, xent, write_len, &lnum, &xent_offs, sync);
1728 if (!sync && !err)
1729 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
1730 release_head(c, BASEHD);
1731
1732 ubifs_add_auth_dirt(c, lnum);
1733 kfree(xent);
1734 if (err)
1735 goto out_ro;
1736
1737
1738 err = ubifs_tnc_remove_nm(c, &xent_key, nm);
1739 if (err)
1740 goto out_ro;
1741 err = ubifs_add_dirt(c, lnum, xlen);
1742 if (err)
1743 goto out_ro;
1744
1745
1746
1747
1748
1749 lowest_ino_key(c, &key1, inode->i_ino);
1750 highest_ino_key(c, &key2, inode->i_ino);
1751 err = ubifs_tnc_remove_range(c, &key1, &key2);
1752 if (err)
1753 goto out_ro;
1754 err = ubifs_add_dirt(c, lnum, UBIFS_INO_NODE_SZ);
1755 if (err)
1756 goto out_ro;
1757
1758
1759 ino_key_init(c, &key1, host->i_ino);
1760 err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen, hash);
1761 if (err)
1762 goto out_ro;
1763
1764 finish_reservation(c);
1765 spin_lock(&host_ui->ui_lock);
1766 host_ui->synced_i_size = host_ui->ui_size;
1767 spin_unlock(&host_ui->ui_lock);
1768 mark_inode_clean(c, host_ui);
1769 return 0;
1770
1771out_release:
1772 kfree(xent);
1773 release_head(c, BASEHD);
1774out_ro:
1775 ubifs_ro_mode(c, err);
1776 finish_reservation(c);
1777 return err;
1778}
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
1794 const struct inode *host)
1795{
1796 int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
1797 struct ubifs_inode *host_ui = ubifs_inode(host);
1798 struct ubifs_ino_node *ino;
1799 union ubifs_key key;
1800 int sync = IS_DIRSYNC(host);
1801 u8 hash_host[UBIFS_HASH_ARR_SZ];
1802 u8 hash[UBIFS_HASH_ARR_SZ];
1803
1804 dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1805 ubifs_assert(c, inode->i_nlink > 0);
1806 ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
1807
1808 len1 = UBIFS_INO_NODE_SZ + host_ui->data_len;
1809 len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode)->data_len;
1810 aligned_len1 = ALIGN(len1, 8);
1811 aligned_len = aligned_len1 + ALIGN(len2, 8);
1812
1813 aligned_len += ubifs_auth_node_sz(c);
1814
1815 ino = kzalloc(aligned_len, GFP_NOFS);
1816 if (!ino)
1817 return -ENOMEM;
1818
1819
1820 err = make_reservation(c, BASEHD, aligned_len);
1821 if (err)
1822 goto out_free;
1823
1824 pack_inode(c, ino, host, 0);
1825 err = ubifs_node_calc_hash(c, ino, hash_host);
1826 if (err)
1827 goto out_release;
1828 pack_inode(c, (void *)ino + aligned_len1, inode, 1);
1829 err = ubifs_node_calc_hash(c, (void *)ino + aligned_len1, hash);
1830 if (err)
1831 goto out_release;
1832
1833 err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
1834 if (!sync && !err) {
1835 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1836
1837 ubifs_wbuf_add_ino_nolock(wbuf, host->i_ino);
1838 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
1839 }
1840 release_head(c, BASEHD);
1841 if (err)
1842 goto out_ro;
1843
1844 ubifs_add_auth_dirt(c, lnum);
1845
1846 ino_key_init(c, &key, host->i_ino);
1847 err = ubifs_tnc_add(c, &key, lnum, offs, len1, hash_host);
1848 if (err)
1849 goto out_ro;
1850
1851 ino_key_init(c, &key, inode->i_ino);
1852 err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2, hash);
1853 if (err)
1854 goto out_ro;
1855
1856 finish_reservation(c);
1857 spin_lock(&host_ui->ui_lock);
1858 host_ui->synced_i_size = host_ui->ui_size;
1859 spin_unlock(&host_ui->ui_lock);
1860 mark_inode_clean(c, host_ui);
1861 kfree(ino);
1862 return 0;
1863
1864out_release:
1865 release_head(c, BASEHD);
1866out_ro:
1867 ubifs_ro_mode(c, err);
1868 finish_reservation(c);
1869out_free:
1870 kfree(ino);
1871 return err;
1872}
1873
1874