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