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
50
51
52
53
54
55
56
57
58
59
60
61#include "ubifs.h"
62
63
64
65
66
67static 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
75
76
77
78static 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
86
87
88static inline void zero_data_node_unused(struct ubifs_data_node *data)
89{
90 memset(data->padding, 0, 2);
91}
92
93
94
95
96
97
98static inline void zero_trun_node_unused(struct ubifs_trun_node *trun)
99{
100 memset(trun->padding, 0, 12);
101}
102
103
104
105
106
107
108
109
110
111
112
113
114
115static 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
122
123
124
125 ubifs_assert(!c->ro_media && !c->ro_mount);
126 squeeze = (jhead == BASEHD);
127again:
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
141
142
143 lnum = ubifs_find_free_space(c, len, &offs, squeeze);
144 if (lnum >= 0) {
145
146 err = ubifs_add_bud_to_log(c, jhead, lnum, offs);
147 if (err)
148 goto out_return;
149
150 goto out;
151 }
152
153 err = lnum;
154 if (err != -ENOSPC)
155 goto out_unlock;
156
157
158
159
160
161
162 dbg_jnl("no free space in jhead %s, run GC", dbg_jhead(jhead));
163 mutex_unlock(&wbuf->io_mutex);
164
165 lnum = ubifs_garbage_collect(c, 0);
166 if (lnum < 0) {
167 err = lnum;
168 if (err != -ENOSPC)
169 return err;
170
171
172
173
174
175
176
177 dbg_jnl("GC couldn't make a free LEB for jhead %s",
178 dbg_jhead(jhead));
179 if (retries++ < 2) {
180 dbg_jnl("retry (%d)", retries);
181 goto again;
182 }
183
184 dbg_jnl("return -ENOSPC");
185 return err;
186 }
187
188 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
189 dbg_jnl("got LEB %d for jhead %s", lnum, dbg_jhead(jhead));
190 avail = c->leb_size - wbuf->offs - wbuf->used;
191
192 if (wbuf->lnum != -1 && avail >= len) {
193
194
195
196
197
198 dbg_jnl("return LEB %d back, already have LEB %d:%d",
199 lnum, wbuf->lnum, wbuf->offs + wbuf->used);
200 err = ubifs_return_leb(c, lnum);
201 if (err)
202 goto out_unlock;
203 return 0;
204 }
205
206 err = ubifs_add_bud_to_log(c, jhead, lnum, 0);
207 if (err)
208 goto out_return;
209 offs = 0;
210
211out:
212 err = ubifs_wbuf_seek_nolock(wbuf, lnum, offs, wbuf->dtype);
213 if (err)
214 goto out_unlock;
215
216 return 0;
217
218out_unlock:
219 mutex_unlock(&wbuf->io_mutex);
220 return err;
221
222out_return:
223
224 ubifs_assert(err < 0);
225 err1 = ubifs_return_leb(c, lnum);
226 if (err1 && err == -EAGAIN)
227
228
229
230
231
232 err = err1;
233 mutex_unlock(&wbuf->io_mutex);
234 return err;
235}
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250static int write_node(struct ubifs_info *c, int jhead, void *node, int len,
251 int *lnum, int *offs)
252{
253 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
254
255 ubifs_assert(jhead != GCHD);
256
257 *lnum = c->jheads[jhead].wbuf.lnum;
258 *offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
259
260 dbg_jnl("jhead %s, LEB %d:%d, len %d",
261 dbg_jhead(jhead), *lnum, *offs, len);
262 ubifs_prepare_node(c, node, len, 0);
263
264 return ubifs_wbuf_write_nolock(wbuf, node, len);
265}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281static int write_head(struct ubifs_info *c, int jhead, void *buf, int len,
282 int *lnum, int *offs, int sync)
283{
284 int err;
285 struct ubifs_wbuf *wbuf = &c->jheads[jhead].wbuf;
286
287 ubifs_assert(jhead != GCHD);
288
289 *lnum = c->jheads[jhead].wbuf.lnum;
290 *offs = c->jheads[jhead].wbuf.offs + c->jheads[jhead].wbuf.used;
291 dbg_jnl("jhead %s, LEB %d:%d, len %d",
292 dbg_jhead(jhead), *lnum, *offs, len);
293
294 err = ubifs_wbuf_write_nolock(wbuf, buf, len);
295 if (err)
296 return err;
297 if (sync)
298 err = ubifs_wbuf_sync_nolock(wbuf);
299 return err;
300}
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318static int make_reservation(struct ubifs_info *c, int jhead, int len)
319{
320 int err, cmt_retries = 0, nospc_retries = 0;
321
322again:
323 down_read(&c->commit_sem);
324 err = reserve_space(c, jhead, len);
325 if (!err)
326 return 0;
327 up_read(&c->commit_sem);
328
329 if (err == -ENOSPC) {
330
331
332
333
334
335
336 if (nospc_retries++ < 2) {
337 dbg_jnl("no space, retry");
338 err = -EAGAIN;
339 }
340
341
342
343
344
345
346
347 }
348
349 if (err != -EAGAIN)
350 goto out;
351
352
353
354
355
356 if (cmt_retries > 128) {
357
358
359
360
361 ubifs_err("stuck in space allocation");
362 err = -ENOSPC;
363 goto out;
364 } else if (cmt_retries > 32)
365 ubifs_warn("too many space allocation re-tries (%d)",
366 cmt_retries);
367
368 dbg_jnl("-EAGAIN, commit and retry (retried %d times)",
369 cmt_retries);
370 cmt_retries += 1;
371
372 err = ubifs_run_commit(c);
373 if (err)
374 return err;
375 goto again;
376
377out:
378 ubifs_err("cannot reserve %d bytes in jhead %d, error %d",
379 len, jhead, err);
380 if (err == -ENOSPC) {
381
382 down_write(&c->commit_sem);
383 spin_lock(&c->space_lock);
384 dbg_dump_stack();
385 dbg_dump_budg(c);
386 spin_unlock(&c->space_lock);
387 dbg_dump_lprops(c);
388 cmt_retries = dbg_check_lprops(c);
389 up_write(&c->commit_sem);
390 }
391 return err;
392}
393
394
395
396
397
398
399
400
401
402
403static inline void release_head(struct ubifs_info *c, int jhead)
404{
405 mutex_unlock(&c->jheads[jhead].wbuf.io_mutex);
406}
407
408
409
410
411
412
413
414
415static void finish_reservation(struct ubifs_info *c)
416{
417 up_read(&c->commit_sem);
418}
419
420
421
422
423
424static int get_dent_type(int mode)
425{
426 switch (mode & S_IFMT) {
427 case S_IFREG:
428 return UBIFS_ITYPE_REG;
429 case S_IFDIR:
430 return UBIFS_ITYPE_DIR;
431 case S_IFLNK:
432 return UBIFS_ITYPE_LNK;
433 case S_IFBLK:
434 return UBIFS_ITYPE_BLK;
435 case S_IFCHR:
436 return UBIFS_ITYPE_CHR;
437 case S_IFIFO:
438 return UBIFS_ITYPE_FIFO;
439 case S_IFSOCK:
440 return UBIFS_ITYPE_SOCK;
441 default:
442 BUG();
443 }
444 return 0;
445}
446
447
448
449
450
451
452
453
454static void pack_inode(struct ubifs_info *c, struct ubifs_ino_node *ino,
455 const struct inode *inode, int last)
456{
457 int data_len = 0, last_reference = !inode->i_nlink;
458 struct ubifs_inode *ui = ubifs_inode(inode);
459
460 ino->ch.node_type = UBIFS_INO_NODE;
461 ino_key_init_flash(c, &ino->key, inode->i_ino);
462 ino->creat_sqnum = cpu_to_le64(ui->creat_sqnum);
463 ino->atime_sec = cpu_to_le64(inode->i_atime.tv_sec);
464 ino->atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
465 ino->ctime_sec = cpu_to_le64(inode->i_ctime.tv_sec);
466 ino->ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
467 ino->mtime_sec = cpu_to_le64(inode->i_mtime.tv_sec);
468 ino->mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
469 ino->uid = cpu_to_le32(inode->i_uid);
470 ino->gid = cpu_to_le32(inode->i_gid);
471 ino->mode = cpu_to_le32(inode->i_mode);
472 ino->flags = cpu_to_le32(ui->flags);
473 ino->size = cpu_to_le64(ui->ui_size);
474 ino->nlink = cpu_to_le32(inode->i_nlink);
475 ino->compr_type = cpu_to_le16(ui->compr_type);
476 ino->data_len = cpu_to_le32(ui->data_len);
477 ino->xattr_cnt = cpu_to_le32(ui->xattr_cnt);
478 ino->xattr_size = cpu_to_le32(ui->xattr_size);
479 ino->xattr_names = cpu_to_le32(ui->xattr_names);
480 zero_ino_node_unused(ino);
481
482
483
484
485
486 if (!last_reference) {
487 memcpy(ino->data, ui->data, ui->data_len);
488 data_len = ui->data_len;
489 }
490
491 ubifs_prep_grp_node(c, ino, UBIFS_INO_NODE_SZ + data_len, last);
492}
493
494
495
496
497
498
499
500
501
502
503
504static void mark_inode_clean(struct ubifs_info *c, struct ubifs_inode *ui)
505{
506 if (ui->dirty)
507 ubifs_release_dirty_inode_budget(c, ui);
508 ui->dirty = 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 qstr *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 *dir_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
551 dbg_jnl("ino %lu, dent '%.*s', data len %d in dir ino %lu",
552 inode->i_ino, nm->len, nm->name, ui->data_len, dir->i_ino);
553 ubifs_assert(dir_ui->data_len == 0);
554 ubifs_assert(mutex_is_locked(&dir_ui->ui_mutex));
555
556 dlen = UBIFS_DENT_NODE_SZ + nm->len + 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 len = aligned_dlen + aligned_ilen + UBIFS_INO_NODE_SZ;
573 dent = kmalloc(len, GFP_NOFS);
574 if (!dent)
575 return -ENOMEM;
576
577
578 err = make_reservation(c, BASEHD, len);
579 if (err)
580 goto out_free;
581
582 if (!xent) {
583 dent->ch.node_type = UBIFS_DENT_NODE;
584 dent_key_init(c, &dent_key, dir->i_ino, nm);
585 } else {
586 dent->ch.node_type = UBIFS_XENT_NODE;
587 xent_key_init(c, &dent_key, dir->i_ino, nm);
588 }
589
590 key_write(c, &dent_key, dent->key);
591 dent->inum = deletion ? 0 : cpu_to_le64(inode->i_ino);
592 dent->type = get_dent_type(inode->i_mode);
593 dent->nlen = cpu_to_le16(nm->len);
594 memcpy(dent->name, nm->name, nm->len);
595 dent->name[nm->len] = '\0';
596 zero_dent_node_unused(dent);
597 ubifs_prep_grp_node(c, dent, dlen, 0);
598
599 ino = (void *)dent + aligned_dlen;
600 pack_inode(c, ino, inode, 0);
601 ino = (void *)ino + aligned_ilen;
602 pack_inode(c, ino, dir, 1);
603
604 if (last_reference) {
605 err = ubifs_add_orphan(c, inode->i_ino);
606 if (err) {
607 release_head(c, BASEHD);
608 goto out_finish;
609 }
610 ui->del_cmtno = c->cmt_no;
611 }
612
613 err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
614 if (err)
615 goto out_release;
616 if (!sync) {
617 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
618
619 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
620 ubifs_wbuf_add_ino_nolock(wbuf, dir->i_ino);
621 }
622 release_head(c, BASEHD);
623 kfree(dent);
624
625 if (deletion) {
626 err = ubifs_tnc_remove_nm(c, &dent_key, nm);
627 if (err)
628 goto out_ro;
629 err = ubifs_add_dirt(c, lnum, dlen);
630 } else
631 err = ubifs_tnc_add_nm(c, &dent_key, lnum, dent_offs, dlen, nm);
632 if (err)
633 goto out_ro;
634
635
636
637
638
639
640
641 ino_key_init(c, &ino_key, inode->i_ino);
642 ino_offs = dent_offs + aligned_dlen;
643 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, ilen);
644 if (err)
645 goto out_ro;
646
647 ino_key_init(c, &ino_key, dir->i_ino);
648 ino_offs += aligned_ilen;
649 err = ubifs_tnc_add(c, &ino_key, lnum, ino_offs, UBIFS_INO_NODE_SZ);
650 if (err)
651 goto out_ro;
652
653 finish_reservation(c);
654 spin_lock(&ui->ui_lock);
655 ui->synced_i_size = ui->ui_size;
656 spin_unlock(&ui->ui_lock);
657 mark_inode_clean(c, ui);
658 mark_inode_clean(c, dir_ui);
659 return 0;
660
661out_finish:
662 finish_reservation(c);
663out_free:
664 kfree(dent);
665 return err;
666
667out_release:
668 release_head(c, BASEHD);
669out_ro:
670 ubifs_ro_mode(c, err);
671 if (last_reference)
672 ubifs_delete_orphan(c, inode->i_ino);
673 finish_reservation(c);
674 return err;
675}
676
677
678
679
680
681
682
683
684
685
686
687
688int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
689 const union ubifs_key *key, const void *buf, int len)
690{
691 struct ubifs_data_node *data;
692 int err, lnum, offs, compr_type, out_len;
693 int dlen = UBIFS_DATA_NODE_SZ + UBIFS_BLOCK_SIZE * WORST_COMPR_FACTOR;
694 struct ubifs_inode *ui = ubifs_inode(inode);
695
696 dbg_jnl("ino %lu, blk %u, len %d, key %s",
697 (unsigned long)key_inum(c, key), key_block(c, key), len,
698 DBGKEY(key));
699 ubifs_assert(len <= UBIFS_BLOCK_SIZE);
700
701 data = kmalloc(dlen, GFP_NOFS);
702 if (!data)
703 return -ENOMEM;
704
705 data->ch.node_type = UBIFS_DATA_NODE;
706 key_write(c, key, &data->key);
707 data->size = cpu_to_le32(len);
708 zero_data_node_unused(data);
709
710 if (!(ui->flags & UBIFS_COMPR_FL))
711
712 compr_type = UBIFS_COMPR_NONE;
713 else
714 compr_type = ui->compr_type;
715
716 out_len = dlen - UBIFS_DATA_NODE_SZ;
717 ubifs_compress(buf, len, &data->data, &out_len, &compr_type);
718 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
719
720 dlen = UBIFS_DATA_NODE_SZ + out_len;
721 data->compr_type = cpu_to_le16(compr_type);
722
723
724 err = make_reservation(c, DATAHD, dlen);
725 if (err)
726 goto out_free;
727
728 err = write_node(c, DATAHD, data, dlen, &lnum, &offs);
729 if (err)
730 goto out_release;
731 ubifs_wbuf_add_ino_nolock(&c->jheads[DATAHD].wbuf, key_inum(c, key));
732 release_head(c, DATAHD);
733
734 err = ubifs_tnc_add(c, key, lnum, offs, dlen);
735 if (err)
736 goto out_ro;
737
738 finish_reservation(c);
739 kfree(data);
740 return 0;
741
742out_release:
743 release_head(c, DATAHD);
744out_ro:
745 ubifs_ro_mode(c, err);
746 finish_reservation(c);
747out_free:
748 kfree(data);
749 return err;
750}
751
752
753
754
755
756
757
758
759
760
761int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode)
762{
763 int err, lnum, offs;
764 struct ubifs_ino_node *ino;
765 struct ubifs_inode *ui = ubifs_inode(inode);
766 int sync = 0, len = UBIFS_INO_NODE_SZ, last_reference = !inode->i_nlink;
767
768 dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
769
770
771
772
773
774 if (!last_reference) {
775 len += ui->data_len;
776 sync = IS_SYNC(inode);
777 }
778 ino = kmalloc(len, GFP_NOFS);
779 if (!ino)
780 return -ENOMEM;
781
782
783 err = make_reservation(c, BASEHD, len);
784 if (err)
785 goto out_free;
786
787 pack_inode(c, ino, inode, 1);
788 err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
789 if (err)
790 goto out_release;
791 if (!sync)
792 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
793 inode->i_ino);
794 release_head(c, BASEHD);
795
796 if (last_reference) {
797 err = ubifs_tnc_remove_ino(c, inode->i_ino);
798 if (err)
799 goto out_ro;
800 ubifs_delete_orphan(c, inode->i_ino);
801 err = ubifs_add_dirt(c, lnum, len);
802 } else {
803 union ubifs_key key;
804
805 ino_key_init(c, &key, inode->i_ino);
806 err = ubifs_tnc_add(c, &key, lnum, offs, len);
807 }
808 if (err)
809 goto out_ro;
810
811 finish_reservation(c);
812 spin_lock(&ui->ui_lock);
813 ui->synced_i_size = ui->ui_size;
814 spin_unlock(&ui->ui_lock);
815 kfree(ino);
816 return 0;
817
818out_release:
819 release_head(c, BASEHD);
820out_ro:
821 ubifs_ro_mode(c, err);
822 finish_reservation(c);
823out_free:
824 kfree(ino);
825 return err;
826}
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode)
858{
859 int err;
860 struct ubifs_inode *ui = ubifs_inode(inode);
861
862 ubifs_assert(inode->i_nlink == 0);
863
864 if (ui->del_cmtno != c->cmt_no)
865
866 return ubifs_jnl_write_inode(c, inode);
867
868 down_read(&c->commit_sem);
869
870
871
872
873 if (ui->del_cmtno != c->cmt_no) {
874 up_read(&c->commit_sem);
875 return ubifs_jnl_write_inode(c, inode);
876 }
877
878 err = ubifs_tnc_remove_ino(c, inode->i_ino);
879 if (err)
880 ubifs_ro_mode(c, err);
881 else
882 ubifs_delete_orphan(c, inode->i_ino);
883 up_read(&c->commit_sem);
884 return err;
885}
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
902 const struct dentry *old_dentry,
903 const struct inode *new_dir,
904 const struct dentry *new_dentry, int sync)
905{
906 void *p;
907 union ubifs_key key;
908 struct ubifs_dent_node *dent, *dent2;
909 int err, dlen1, dlen2, ilen, lnum, offs, len;
910 const struct inode *old_inode = old_dentry->d_inode;
911 const struct inode *new_inode = new_dentry->d_inode;
912 int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ;
913 int last_reference = !!(new_inode && new_inode->i_nlink == 0);
914 int move = (old_dir != new_dir);
915 struct ubifs_inode *uninitialized_var(new_ui);
916
917 dbg_jnl("dent '%.*s' in dir ino %lu to dent '%.*s' in dir ino %lu",
918 old_dentry->d_name.len, old_dentry->d_name.name,
919 old_dir->i_ino, new_dentry->d_name.len,
920 new_dentry->d_name.name, new_dir->i_ino);
921 ubifs_assert(ubifs_inode(old_dir)->data_len == 0);
922 ubifs_assert(ubifs_inode(new_dir)->data_len == 0);
923 ubifs_assert(mutex_is_locked(&ubifs_inode(old_dir)->ui_mutex));
924 ubifs_assert(mutex_is_locked(&ubifs_inode(new_dir)->ui_mutex));
925
926 dlen1 = UBIFS_DENT_NODE_SZ + new_dentry->d_name.len + 1;
927 dlen2 = UBIFS_DENT_NODE_SZ + old_dentry->d_name.len + 1;
928 if (new_inode) {
929 new_ui = ubifs_inode(new_inode);
930 ubifs_assert(mutex_is_locked(&new_ui->ui_mutex));
931 ilen = UBIFS_INO_NODE_SZ;
932 if (!last_reference)
933 ilen += new_ui->data_len;
934 } else
935 ilen = 0;
936
937 aligned_dlen1 = ALIGN(dlen1, 8);
938 aligned_dlen2 = ALIGN(dlen2, 8);
939 len = aligned_dlen1 + aligned_dlen2 + ALIGN(ilen, 8) + ALIGN(plen, 8);
940 if (old_dir != new_dir)
941 len += plen;
942 dent = kmalloc(len, GFP_NOFS);
943 if (!dent)
944 return -ENOMEM;
945
946
947 err = make_reservation(c, BASEHD, len);
948 if (err)
949 goto out_free;
950
951
952 dent->ch.node_type = UBIFS_DENT_NODE;
953 dent_key_init_flash(c, &dent->key, new_dir->i_ino, &new_dentry->d_name);
954 dent->inum = cpu_to_le64(old_inode->i_ino);
955 dent->type = get_dent_type(old_inode->i_mode);
956 dent->nlen = cpu_to_le16(new_dentry->d_name.len);
957 memcpy(dent->name, new_dentry->d_name.name, new_dentry->d_name.len);
958 dent->name[new_dentry->d_name.len] = '\0';
959 zero_dent_node_unused(dent);
960 ubifs_prep_grp_node(c, dent, dlen1, 0);
961
962
963 dent2 = (void *)dent + aligned_dlen1;
964 dent2->ch.node_type = UBIFS_DENT_NODE;
965 dent_key_init_flash(c, &dent2->key, old_dir->i_ino,
966 &old_dentry->d_name);
967 dent2->inum = 0;
968 dent2->type = DT_UNKNOWN;
969 dent2->nlen = cpu_to_le16(old_dentry->d_name.len);
970 memcpy(dent2->name, old_dentry->d_name.name, old_dentry->d_name.len);
971 dent2->name[old_dentry->d_name.len] = '\0';
972 zero_dent_node_unused(dent2);
973 ubifs_prep_grp_node(c, dent2, dlen2, 0);
974
975 p = (void *)dent2 + aligned_dlen2;
976 if (new_inode) {
977 pack_inode(c, p, new_inode, 0);
978 p += ALIGN(ilen, 8);
979 }
980
981 if (!move)
982 pack_inode(c, p, old_dir, 1);
983 else {
984 pack_inode(c, p, old_dir, 0);
985 p += ALIGN(plen, 8);
986 pack_inode(c, p, new_dir, 1);
987 }
988
989 if (last_reference) {
990 err = ubifs_add_orphan(c, new_inode->i_ino);
991 if (err) {
992 release_head(c, BASEHD);
993 goto out_finish;
994 }
995 new_ui->del_cmtno = c->cmt_no;
996 }
997
998 err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
999 if (err)
1000 goto out_release;
1001 if (!sync) {
1002 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1003
1004 ubifs_wbuf_add_ino_nolock(wbuf, new_dir->i_ino);
1005 ubifs_wbuf_add_ino_nolock(wbuf, old_dir->i_ino);
1006 if (new_inode)
1007 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf,
1008 new_inode->i_ino);
1009 }
1010 release_head(c, BASEHD);
1011
1012 dent_key_init(c, &key, new_dir->i_ino, &new_dentry->d_name);
1013 err = ubifs_tnc_add_nm(c, &key, lnum, offs, dlen1, &new_dentry->d_name);
1014 if (err)
1015 goto out_ro;
1016
1017 err = ubifs_add_dirt(c, lnum, dlen2);
1018 if (err)
1019 goto out_ro;
1020
1021 dent_key_init(c, &key, old_dir->i_ino, &old_dentry->d_name);
1022 err = ubifs_tnc_remove_nm(c, &key, &old_dentry->d_name);
1023 if (err)
1024 goto out_ro;
1025
1026 offs += aligned_dlen1 + aligned_dlen2;
1027 if (new_inode) {
1028 ino_key_init(c, &key, new_inode->i_ino);
1029 err = ubifs_tnc_add(c, &key, lnum, offs, ilen);
1030 if (err)
1031 goto out_ro;
1032 offs += ALIGN(ilen, 8);
1033 }
1034
1035 ino_key_init(c, &key, old_dir->i_ino);
1036 err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1037 if (err)
1038 goto out_ro;
1039
1040 if (old_dir != new_dir) {
1041 offs += ALIGN(plen, 8);
1042 ino_key_init(c, &key, new_dir->i_ino);
1043 err = ubifs_tnc_add(c, &key, lnum, offs, plen);
1044 if (err)
1045 goto out_ro;
1046 }
1047
1048 finish_reservation(c);
1049 if (new_inode) {
1050 mark_inode_clean(c, new_ui);
1051 spin_lock(&new_ui->ui_lock);
1052 new_ui->synced_i_size = new_ui->ui_size;
1053 spin_unlock(&new_ui->ui_lock);
1054 }
1055 mark_inode_clean(c, ubifs_inode(old_dir));
1056 if (move)
1057 mark_inode_clean(c, ubifs_inode(new_dir));
1058 kfree(dent);
1059 return 0;
1060
1061out_release:
1062 release_head(c, BASEHD);
1063out_ro:
1064 ubifs_ro_mode(c, err);
1065 if (last_reference)
1066 ubifs_delete_orphan(c, new_inode->i_ino);
1067out_finish:
1068 finish_reservation(c);
1069out_free:
1070 kfree(dent);
1071 return err;
1072}
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082static int recomp_data_node(struct ubifs_data_node *dn, int *new_len)
1083{
1084 void *buf;
1085 int err, len, compr_type, out_len;
1086
1087 out_len = le32_to_cpu(dn->size);
1088 buf = kmalloc(out_len * WORST_COMPR_FACTOR, GFP_NOFS);
1089 if (!buf)
1090 return -ENOMEM;
1091
1092 len = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
1093 compr_type = le16_to_cpu(dn->compr_type);
1094 err = ubifs_decompress(&dn->data, len, buf, &out_len, compr_type);
1095 if (err)
1096 goto out;
1097
1098 ubifs_compress(buf, *new_len, &dn->data, &out_len, &compr_type);
1099 ubifs_assert(out_len <= UBIFS_BLOCK_SIZE);
1100 dn->compr_type = cpu_to_le16(compr_type);
1101 dn->size = cpu_to_le32(*new_len);
1102 *new_len = UBIFS_DATA_NODE_SZ + out_len;
1103out:
1104 kfree(buf);
1105 return err;
1106}
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
1124 loff_t old_size, loff_t new_size)
1125{
1126 union ubifs_key key, to_key;
1127 struct ubifs_ino_node *ino;
1128 struct ubifs_trun_node *trun;
1129 struct ubifs_data_node *uninitialized_var(dn);
1130 int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
1131 struct ubifs_inode *ui = ubifs_inode(inode);
1132 ino_t inum = inode->i_ino;
1133 unsigned int blk;
1134
1135 dbg_jnl("ino %lu, size %lld -> %lld",
1136 (unsigned long)inum, old_size, new_size);
1137 ubifs_assert(!ui->data_len);
1138 ubifs_assert(S_ISREG(inode->i_mode));
1139 ubifs_assert(mutex_is_locked(&ui->ui_mutex));
1140
1141 sz = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ +
1142 UBIFS_MAX_DATA_NODE_SZ * WORST_COMPR_FACTOR;
1143 ino = kmalloc(sz, GFP_NOFS);
1144 if (!ino)
1145 return -ENOMEM;
1146
1147 trun = (void *)ino + UBIFS_INO_NODE_SZ;
1148 trun->ch.node_type = UBIFS_TRUN_NODE;
1149 trun->inum = cpu_to_le32(inum);
1150 trun->old_size = cpu_to_le64(old_size);
1151 trun->new_size = cpu_to_le64(new_size);
1152 zero_trun_node_unused(trun);
1153
1154 dlen = new_size & (UBIFS_BLOCK_SIZE - 1);
1155 if (dlen) {
1156
1157 dn = (void *)trun + UBIFS_TRUN_NODE_SZ;
1158 blk = new_size >> UBIFS_BLOCK_SHIFT;
1159 data_key_init(c, &key, inum, blk);
1160 dbg_jnl("last block key %s", DBGKEY(&key));
1161 err = ubifs_tnc_lookup(c, &key, dn);
1162 if (err == -ENOENT)
1163 dlen = 0;
1164 else if (err)
1165 goto out_free;
1166 else {
1167 if (le32_to_cpu(dn->size) <= dlen)
1168 dlen = 0;
1169 else {
1170 int compr_type = le16_to_cpu(dn->compr_type);
1171
1172 if (compr_type != UBIFS_COMPR_NONE) {
1173 err = recomp_data_node(dn, &dlen);
1174 if (err)
1175 goto out_free;
1176 } else {
1177 dn->size = cpu_to_le32(dlen);
1178 dlen += UBIFS_DATA_NODE_SZ;
1179 }
1180 zero_data_node_unused(dn);
1181 }
1182 }
1183 }
1184
1185
1186 len = UBIFS_TRUN_NODE_SZ + UBIFS_INO_NODE_SZ;
1187 if (dlen)
1188 len += dlen;
1189 err = make_reservation(c, BASEHD, len);
1190 if (err)
1191 goto out_free;
1192
1193 pack_inode(c, ino, inode, 0);
1194 ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
1195 if (dlen)
1196 ubifs_prep_grp_node(c, dn, dlen, 1);
1197
1198 err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
1199 if (err)
1200 goto out_release;
1201 if (!sync)
1202 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, inum);
1203 release_head(c, BASEHD);
1204
1205 if (dlen) {
1206 sz = offs + UBIFS_INO_NODE_SZ + UBIFS_TRUN_NODE_SZ;
1207 err = ubifs_tnc_add(c, &key, lnum, sz, dlen);
1208 if (err)
1209 goto out_ro;
1210 }
1211
1212 ino_key_init(c, &key, inum);
1213 err = ubifs_tnc_add(c, &key, lnum, offs, UBIFS_INO_NODE_SZ);
1214 if (err)
1215 goto out_ro;
1216
1217 err = ubifs_add_dirt(c, lnum, UBIFS_TRUN_NODE_SZ);
1218 if (err)
1219 goto out_ro;
1220
1221 bit = new_size & (UBIFS_BLOCK_SIZE - 1);
1222 blk = (new_size >> UBIFS_BLOCK_SHIFT) + (bit ? 1 : 0);
1223 data_key_init(c, &key, inum, blk);
1224
1225 bit = old_size & (UBIFS_BLOCK_SIZE - 1);
1226 blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0 : 1);
1227 data_key_init(c, &to_key, inum, blk);
1228
1229 err = ubifs_tnc_remove_range(c, &key, &to_key);
1230 if (err)
1231 goto out_ro;
1232
1233 finish_reservation(c);
1234 spin_lock(&ui->ui_lock);
1235 ui->synced_i_size = ui->ui_size;
1236 spin_unlock(&ui->ui_lock);
1237 mark_inode_clean(c, ui);
1238 kfree(ino);
1239 return 0;
1240
1241out_release:
1242 release_head(c, BASEHD);
1243out_ro:
1244 ubifs_ro_mode(c, err);
1245 finish_reservation(c);
1246out_free:
1247 kfree(ino);
1248 return err;
1249}
1250
1251#ifdef CONFIG_UBIFS_FS_XATTR
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
1266 const struct inode *inode, const struct qstr *nm)
1267{
1268 int err, xlen, hlen, len, lnum, xent_offs, aligned_xlen;
1269 struct ubifs_dent_node *xent;
1270 struct ubifs_ino_node *ino;
1271 union ubifs_key xent_key, key1, key2;
1272 int sync = IS_DIRSYNC(host);
1273 struct ubifs_inode *host_ui = ubifs_inode(host);
1274
1275 dbg_jnl("host %lu, xattr ino %lu, name '%s', data len %d",
1276 host->i_ino, inode->i_ino, nm->name,
1277 ubifs_inode(inode)->data_len);
1278 ubifs_assert(inode->i_nlink == 0);
1279 ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
1280
1281
1282
1283
1284
1285 xlen = UBIFS_DENT_NODE_SZ + nm->len + 1;
1286 aligned_xlen = ALIGN(xlen, 8);
1287 hlen = host_ui->data_len + UBIFS_INO_NODE_SZ;
1288 len = aligned_xlen + UBIFS_INO_NODE_SZ + ALIGN(hlen, 8);
1289
1290 xent = kmalloc(len, GFP_NOFS);
1291 if (!xent)
1292 return -ENOMEM;
1293
1294
1295 err = make_reservation(c, BASEHD, len);
1296 if (err) {
1297 kfree(xent);
1298 return err;
1299 }
1300
1301 xent->ch.node_type = UBIFS_XENT_NODE;
1302 xent_key_init(c, &xent_key, host->i_ino, nm);
1303 key_write(c, &xent_key, xent->key);
1304 xent->inum = 0;
1305 xent->type = get_dent_type(inode->i_mode);
1306 xent->nlen = cpu_to_le16(nm->len);
1307 memcpy(xent->name, nm->name, nm->len);
1308 xent->name[nm->len] = '\0';
1309 zero_dent_node_unused(xent);
1310 ubifs_prep_grp_node(c, xent, xlen, 0);
1311
1312 ino = (void *)xent + aligned_xlen;
1313 pack_inode(c, ino, inode, 0);
1314 ino = (void *)ino + UBIFS_INO_NODE_SZ;
1315 pack_inode(c, ino, host, 1);
1316
1317 err = write_head(c, BASEHD, xent, len, &lnum, &xent_offs, sync);
1318 if (!sync && !err)
1319 ubifs_wbuf_add_ino_nolock(&c->jheads[BASEHD].wbuf, host->i_ino);
1320 release_head(c, BASEHD);
1321 kfree(xent);
1322 if (err)
1323 goto out_ro;
1324
1325
1326 err = ubifs_tnc_remove_nm(c, &xent_key, nm);
1327 if (err)
1328 goto out_ro;
1329 err = ubifs_add_dirt(c, lnum, xlen);
1330 if (err)
1331 goto out_ro;
1332
1333
1334
1335
1336
1337 lowest_ino_key(c, &key1, inode->i_ino);
1338 highest_ino_key(c, &key2, inode->i_ino);
1339 err = ubifs_tnc_remove_range(c, &key1, &key2);
1340 if (err)
1341 goto out_ro;
1342 err = ubifs_add_dirt(c, lnum, UBIFS_INO_NODE_SZ);
1343 if (err)
1344 goto out_ro;
1345
1346
1347 ino_key_init(c, &key1, host->i_ino);
1348 err = ubifs_tnc_add(c, &key1, lnum, xent_offs + len - hlen, hlen);
1349 if (err)
1350 goto out_ro;
1351
1352 finish_reservation(c);
1353 spin_lock(&host_ui->ui_lock);
1354 host_ui->synced_i_size = host_ui->ui_size;
1355 spin_unlock(&host_ui->ui_lock);
1356 mark_inode_clean(c, host_ui);
1357 return 0;
1358
1359out_ro:
1360 ubifs_ro_mode(c, err);
1361 finish_reservation(c);
1362 return err;
1363}
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
1379 const struct inode *host)
1380{
1381 int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
1382 struct ubifs_inode *host_ui = ubifs_inode(host);
1383 struct ubifs_ino_node *ino;
1384 union ubifs_key key;
1385 int sync = IS_DIRSYNC(host);
1386
1387 dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1388 ubifs_assert(host->i_nlink > 0);
1389 ubifs_assert(inode->i_nlink > 0);
1390 ubifs_assert(mutex_is_locked(&host_ui->ui_mutex));
1391
1392 len1 = UBIFS_INO_NODE_SZ + host_ui->data_len;
1393 len2 = UBIFS_INO_NODE_SZ + ubifs_inode(inode)->data_len;
1394 aligned_len1 = ALIGN(len1, 8);
1395 aligned_len = aligned_len1 + ALIGN(len2, 8);
1396
1397 ino = kmalloc(aligned_len, GFP_NOFS);
1398 if (!ino)
1399 return -ENOMEM;
1400
1401
1402 err = make_reservation(c, BASEHD, aligned_len);
1403 if (err)
1404 goto out_free;
1405
1406 pack_inode(c, ino, host, 0);
1407 pack_inode(c, (void *)ino + aligned_len1, inode, 1);
1408
1409 err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
1410 if (!sync && !err) {
1411 struct ubifs_wbuf *wbuf = &c->jheads[BASEHD].wbuf;
1412
1413 ubifs_wbuf_add_ino_nolock(wbuf, host->i_ino);
1414 ubifs_wbuf_add_ino_nolock(wbuf, inode->i_ino);
1415 }
1416 release_head(c, BASEHD);
1417 if (err)
1418 goto out_ro;
1419
1420 ino_key_init(c, &key, host->i_ino);
1421 err = ubifs_tnc_add(c, &key, lnum, offs, len1);
1422 if (err)
1423 goto out_ro;
1424
1425 ino_key_init(c, &key, inode->i_ino);
1426 err = ubifs_tnc_add(c, &key, lnum, offs + aligned_len1, len2);
1427 if (err)
1428 goto out_ro;
1429
1430 finish_reservation(c);
1431 spin_lock(&host_ui->ui_lock);
1432 host_ui->synced_i_size = host_ui->ui_size;
1433 spin_unlock(&host_ui->ui_lock);
1434 mark_inode_clean(c, host_ui);
1435 kfree(ino);
1436 return 0;
1437
1438out_ro:
1439 ubifs_ro_mode(c, err);
1440 finish_reservation(c);
1441out_free:
1442 kfree(ino);
1443 return err;
1444}
1445
1446#endif
1447