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#include "ubifs.h"
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59static int inherit_flags(const struct inode *dir, umode_t mode)
60{
61 int flags;
62 const struct ubifs_inode *ui = ubifs_inode(dir);
63
64 if (!S_ISDIR(dir->i_mode))
65
66
67
68
69 return 0;
70
71 flags = ui->flags & (UBIFS_COMPR_FL | UBIFS_SYNC_FL | UBIFS_DIRSYNC_FL);
72 if (!S_ISDIR(mode))
73
74 flags &= ~UBIFS_DIRSYNC_FL;
75 return flags;
76}
77
78
79
80
81
82
83
84
85
86
87
88struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
89 umode_t mode)
90{
91 struct inode *inode;
92 struct ubifs_inode *ui;
93
94 inode = new_inode(c->vfs_sb);
95 ui = ubifs_inode(inode);
96 if (!inode)
97 return ERR_PTR(-ENOMEM);
98
99
100
101
102
103
104
105 inode->i_flags |= S_NOCMTIME;
106
107 inode_init_owner(inode, dir, mode);
108 inode->i_mtime = inode->i_atime = inode->i_ctime =
109 ubifs_current_time(inode);
110 inode->i_mapping->nrpages = 0;
111
112 inode->i_mapping->backing_dev_info = &c->bdi;
113
114 switch (mode & S_IFMT) {
115 case S_IFREG:
116 inode->i_mapping->a_ops = &ubifs_file_address_operations;
117 inode->i_op = &ubifs_file_inode_operations;
118 inode->i_fop = &ubifs_file_operations;
119 break;
120 case S_IFDIR:
121 inode->i_op = &ubifs_dir_inode_operations;
122 inode->i_fop = &ubifs_dir_operations;
123 inode->i_size = ui->ui_size = UBIFS_INO_NODE_SZ;
124 break;
125 case S_IFLNK:
126 inode->i_op = &ubifs_symlink_inode_operations;
127 break;
128 case S_IFSOCK:
129 case S_IFIFO:
130 case S_IFBLK:
131 case S_IFCHR:
132 inode->i_op = &ubifs_file_inode_operations;
133 break;
134 default:
135 BUG();
136 }
137
138 ui->flags = inherit_flags(dir, mode);
139 ubifs_set_inode_flags(inode);
140 if (S_ISREG(mode))
141 ui->compr_type = c->default_compr;
142 else
143 ui->compr_type = UBIFS_COMPR_NONE;
144 ui->synced_i_size = 0;
145
146 spin_lock(&c->cnt_lock);
147
148 if (c->highest_inum >= INUM_WARN_WATERMARK) {
149 if (c->highest_inum >= INUM_WATERMARK) {
150 spin_unlock(&c->cnt_lock);
151 ubifs_err("out of inode numbers");
152 make_bad_inode(inode);
153 iput(inode);
154 return ERR_PTR(-EINVAL);
155 }
156 ubifs_warn("running out of inode numbers (current %lu, max %d)",
157 (unsigned long)c->highest_inum, INUM_WATERMARK);
158 }
159
160 inode->i_ino = ++c->highest_inum;
161
162
163
164
165
166
167
168 ui->creat_sqnum = ++c->max_sqnum;
169 spin_unlock(&c->cnt_lock);
170 return inode;
171}
172
173static int dbg_check_name(const struct ubifs_info *c,
174 const struct ubifs_dent_node *dent,
175 const struct qstr *nm)
176{
177 if (!dbg_is_chk_gen(c))
178 return 0;
179 if (le16_to_cpu(dent->nlen) != nm->len)
180 return -EINVAL;
181 if (memcmp(dent->name, nm->name, nm->len))
182 return -EINVAL;
183 return 0;
184}
185
186static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
187 unsigned int flags)
188{
189 int err;
190 union ubifs_key key;
191 struct inode *inode = NULL;
192 struct ubifs_dent_node *dent;
193 struct ubifs_info *c = dir->i_sb->s_fs_info;
194
195 dbg_gen("'%.*s' in dir ino %lu",
196 dentry->d_name.len, dentry->d_name.name, dir->i_ino);
197
198 if (dentry->d_name.len > UBIFS_MAX_NLEN)
199 return ERR_PTR(-ENAMETOOLONG);
200
201 dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
202 if (!dent)
203 return ERR_PTR(-ENOMEM);
204
205 dent_key_init(c, &key, dir->i_ino, &dentry->d_name);
206
207 err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name);
208 if (err) {
209 if (err == -ENOENT) {
210 dbg_gen("not found");
211 goto done;
212 }
213 goto out;
214 }
215
216 if (dbg_check_name(c, dent, &dentry->d_name)) {
217 err = -EINVAL;
218 goto out;
219 }
220
221 inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
222 if (IS_ERR(inode)) {
223
224
225
226
227 err = PTR_ERR(inode);
228 ubifs_err("dead directory entry '%.*s', error %d",
229 dentry->d_name.len, dentry->d_name.name, err);
230 ubifs_ro_mode(c, err);
231 goto out;
232 }
233
234done:
235 kfree(dent);
236
237
238
239
240 d_add(dentry, inode);
241 return NULL;
242
243out:
244 kfree(dent);
245 return ERR_PTR(err);
246}
247
248static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
249 bool excl)
250{
251 struct inode *inode;
252 struct ubifs_info *c = dir->i_sb->s_fs_info;
253 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
254 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
255 .dirtied_ino = 1 };
256 struct ubifs_inode *dir_ui = ubifs_inode(dir);
257
258
259
260
261
262
263 dbg_gen("dent '%.*s', mode %#hx in dir ino %lu",
264 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
265
266 err = ubifs_budget_space(c, &req);
267 if (err)
268 return err;
269
270 inode = ubifs_new_inode(c, dir, mode);
271 if (IS_ERR(inode)) {
272 err = PTR_ERR(inode);
273 goto out_budg;
274 }
275
276 mutex_lock(&dir_ui->ui_mutex);
277 dir->i_size += sz_change;
278 dir_ui->ui_size = dir->i_size;
279 dir->i_mtime = dir->i_ctime = inode->i_ctime;
280 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
281 if (err)
282 goto out_cancel;
283 mutex_unlock(&dir_ui->ui_mutex);
284
285 ubifs_release_budget(c, &req);
286 insert_inode_hash(inode);
287 d_instantiate(dentry, inode);
288 return 0;
289
290out_cancel:
291 dir->i_size -= sz_change;
292 dir_ui->ui_size = dir->i_size;
293 mutex_unlock(&dir_ui->ui_mutex);
294 make_bad_inode(inode);
295 iput(inode);
296out_budg:
297 ubifs_release_budget(c, &req);
298 ubifs_err("cannot create regular file, error %d", err);
299 return err;
300}
301
302
303
304
305
306
307
308
309static unsigned int vfs_dent_type(uint8_t type)
310{
311 switch (type) {
312 case UBIFS_ITYPE_REG:
313 return DT_REG;
314 case UBIFS_ITYPE_DIR:
315 return DT_DIR;
316 case UBIFS_ITYPE_LNK:
317 return DT_LNK;
318 case UBIFS_ITYPE_BLK:
319 return DT_BLK;
320 case UBIFS_ITYPE_CHR:
321 return DT_CHR;
322 case UBIFS_ITYPE_FIFO:
323 return DT_FIFO;
324 case UBIFS_ITYPE_SOCK:
325 return DT_SOCK;
326 default:
327 BUG();
328 }
329 return 0;
330}
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349static int ubifs_readdir(struct file *file, struct dir_context *ctx)
350{
351 int err;
352 struct qstr nm;
353 union ubifs_key key;
354 struct ubifs_dent_node *dent;
355 struct inode *dir = file_inode(file);
356 struct ubifs_info *c = dir->i_sb->s_fs_info;
357
358 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
359
360 if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
361
362
363
364
365 return 0;
366
367 if (file->f_version == 0) {
368
369
370
371
372
373
374
375 kfree(file->private_data);
376 file->private_data = NULL;
377 }
378
379
380
381
382
383 file->f_version = 1;
384
385
386 if (ctx->pos < 2) {
387 ubifs_assert(!file->private_data);
388 if (!dir_emit_dots(file, ctx))
389 return 0;
390
391
392 lowest_dent_key(c, &key, dir->i_ino);
393 nm.name = NULL;
394 dent = ubifs_tnc_next_ent(c, &key, &nm);
395 if (IS_ERR(dent)) {
396 err = PTR_ERR(dent);
397 goto out;
398 }
399
400 ctx->pos = key_hash_flash(c, &dent->key);
401 file->private_data = dent;
402 }
403
404 dent = file->private_data;
405 if (!dent) {
406
407
408
409
410 dent_key_init_hash(c, &key, dir->i_ino, ctx->pos);
411 nm.name = NULL;
412 dent = ubifs_tnc_next_ent(c, &key, &nm);
413 if (IS_ERR(dent)) {
414 err = PTR_ERR(dent);
415 goto out;
416 }
417 ctx->pos = key_hash_flash(c, &dent->key);
418 file->private_data = dent;
419 }
420
421 while (1) {
422 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
423 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
424 key_hash_flash(c, &dent->key));
425 ubifs_assert(le64_to_cpu(dent->ch.sqnum) >
426 ubifs_inode(dir)->creat_sqnum);
427
428 nm.len = le16_to_cpu(dent->nlen);
429 if (!dir_emit(ctx, dent->name, nm.len,
430 le64_to_cpu(dent->inum),
431 vfs_dent_type(dent->type)))
432 return 0;
433
434
435 key_read(c, &dent->key, &key);
436 nm.name = dent->name;
437 dent = ubifs_tnc_next_ent(c, &key, &nm);
438 if (IS_ERR(dent)) {
439 err = PTR_ERR(dent);
440 goto out;
441 }
442
443 kfree(file->private_data);
444 ctx->pos = key_hash_flash(c, &dent->key);
445 file->private_data = dent;
446 cond_resched();
447 }
448
449out:
450 if (err != -ENOENT) {
451 ubifs_err("cannot find next direntry, error %d", err);
452 return err;
453 }
454
455 kfree(file->private_data);
456 file->private_data = NULL;
457
458 ctx->pos = 2;
459 return 0;
460}
461
462
463static int ubifs_dir_release(struct inode *dir, struct file *file)
464{
465 kfree(file->private_data);
466 file->private_data = NULL;
467 return 0;
468}
469
470
471
472
473
474
475
476
477
478
479static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
480{
481 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
482 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
483}
484
485
486
487
488
489
490static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
491{
492 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
493 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
494}
495
496static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
497 struct dentry *dentry)
498{
499 struct ubifs_info *c = dir->i_sb->s_fs_info;
500 struct inode *inode = old_dentry->d_inode;
501 struct ubifs_inode *ui = ubifs_inode(inode);
502 struct ubifs_inode *dir_ui = ubifs_inode(dir);
503 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
504 struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
505 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
506
507
508
509
510
511
512 dbg_gen("dent '%.*s' to ino %lu (nlink %d) in dir ino %lu",
513 dentry->d_name.len, dentry->d_name.name, inode->i_ino,
514 inode->i_nlink, dir->i_ino);
515 ubifs_assert(mutex_is_locked(&dir->i_mutex));
516 ubifs_assert(mutex_is_locked(&inode->i_mutex));
517
518 err = dbg_check_synced_i_size(c, inode);
519 if (err)
520 return err;
521
522 err = ubifs_budget_space(c, &req);
523 if (err)
524 return err;
525
526 lock_2_inodes(dir, inode);
527 inc_nlink(inode);
528 ihold(inode);
529 inode->i_ctime = ubifs_current_time(inode);
530 dir->i_size += sz_change;
531 dir_ui->ui_size = dir->i_size;
532 dir->i_mtime = dir->i_ctime = inode->i_ctime;
533 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
534 if (err)
535 goto out_cancel;
536 unlock_2_inodes(dir, inode);
537
538 ubifs_release_budget(c, &req);
539 d_instantiate(dentry, inode);
540 return 0;
541
542out_cancel:
543 dir->i_size -= sz_change;
544 dir_ui->ui_size = dir->i_size;
545 drop_nlink(inode);
546 unlock_2_inodes(dir, inode);
547 ubifs_release_budget(c, &req);
548 iput(inode);
549 return err;
550}
551
552static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
553{
554 struct ubifs_info *c = dir->i_sb->s_fs_info;
555 struct inode *inode = dentry->d_inode;
556 struct ubifs_inode *dir_ui = ubifs_inode(dir);
557 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
558 int err, budgeted = 1;
559 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
560 unsigned int saved_nlink = inode->i_nlink;
561
562
563
564
565
566
567
568
569 dbg_gen("dent '%.*s' from ino %lu (nlink %d) in dir ino %lu",
570 dentry->d_name.len, dentry->d_name.name, inode->i_ino,
571 inode->i_nlink, dir->i_ino);
572 ubifs_assert(mutex_is_locked(&dir->i_mutex));
573 ubifs_assert(mutex_is_locked(&inode->i_mutex));
574 err = dbg_check_synced_i_size(c, inode);
575 if (err)
576 return err;
577
578 err = ubifs_budget_space(c, &req);
579 if (err) {
580 if (err != -ENOSPC)
581 return err;
582 budgeted = 0;
583 }
584
585 lock_2_inodes(dir, inode);
586 inode->i_ctime = ubifs_current_time(dir);
587 drop_nlink(inode);
588 dir->i_size -= sz_change;
589 dir_ui->ui_size = dir->i_size;
590 dir->i_mtime = dir->i_ctime = inode->i_ctime;
591 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
592 if (err)
593 goto out_cancel;
594 unlock_2_inodes(dir, inode);
595
596 if (budgeted)
597 ubifs_release_budget(c, &req);
598 else {
599
600 c->bi.nospace = c->bi.nospace_rp = 0;
601 smp_wmb();
602 }
603 return 0;
604
605out_cancel:
606 dir->i_size += sz_change;
607 dir_ui->ui_size = dir->i_size;
608 set_nlink(inode, saved_nlink);
609 unlock_2_inodes(dir, inode);
610 if (budgeted)
611 ubifs_release_budget(c, &req);
612 return err;
613}
614
615
616
617
618
619
620
621
622
623
624static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
625{
626 struct qstr nm = { .name = NULL };
627 struct ubifs_dent_node *dent;
628 union ubifs_key key;
629 int err;
630
631 lowest_dent_key(c, &key, dir->i_ino);
632 dent = ubifs_tnc_next_ent(c, &key, &nm);
633 if (IS_ERR(dent)) {
634 err = PTR_ERR(dent);
635 if (err == -ENOENT)
636 err = 0;
637 } else {
638 kfree(dent);
639 err = -ENOTEMPTY;
640 }
641 return err;
642}
643
644static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
645{
646 struct ubifs_info *c = dir->i_sb->s_fs_info;
647 struct inode *inode = dentry->d_inode;
648 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
649 int err, budgeted = 1;
650 struct ubifs_inode *dir_ui = ubifs_inode(dir);
651 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
652
653
654
655
656
657
658
659 dbg_gen("directory '%.*s', ino %lu in dir ino %lu", dentry->d_name.len,
660 dentry->d_name.name, inode->i_ino, dir->i_ino);
661 ubifs_assert(mutex_is_locked(&dir->i_mutex));
662 ubifs_assert(mutex_is_locked(&inode->i_mutex));
663 err = check_dir_empty(c, dentry->d_inode);
664 if (err)
665 return err;
666
667 err = ubifs_budget_space(c, &req);
668 if (err) {
669 if (err != -ENOSPC)
670 return err;
671 budgeted = 0;
672 }
673
674 lock_2_inodes(dir, inode);
675 inode->i_ctime = ubifs_current_time(dir);
676 clear_nlink(inode);
677 drop_nlink(dir);
678 dir->i_size -= sz_change;
679 dir_ui->ui_size = dir->i_size;
680 dir->i_mtime = dir->i_ctime = inode->i_ctime;
681 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
682 if (err)
683 goto out_cancel;
684 unlock_2_inodes(dir, inode);
685
686 if (budgeted)
687 ubifs_release_budget(c, &req);
688 else {
689
690 c->bi.nospace = c->bi.nospace_rp = 0;
691 smp_wmb();
692 }
693 return 0;
694
695out_cancel:
696 dir->i_size += sz_change;
697 dir_ui->ui_size = dir->i_size;
698 inc_nlink(dir);
699 set_nlink(inode, 2);
700 unlock_2_inodes(dir, inode);
701 if (budgeted)
702 ubifs_release_budget(c, &req);
703 return err;
704}
705
706static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
707{
708 struct inode *inode;
709 struct ubifs_inode *dir_ui = ubifs_inode(dir);
710 struct ubifs_info *c = dir->i_sb->s_fs_info;
711 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
712 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
713
714
715
716
717
718
719 dbg_gen("dent '%.*s', mode %#hx in dir ino %lu",
720 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
721
722 err = ubifs_budget_space(c, &req);
723 if (err)
724 return err;
725
726 inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
727 if (IS_ERR(inode)) {
728 err = PTR_ERR(inode);
729 goto out_budg;
730 }
731
732 mutex_lock(&dir_ui->ui_mutex);
733 insert_inode_hash(inode);
734 inc_nlink(inode);
735 inc_nlink(dir);
736 dir->i_size += sz_change;
737 dir_ui->ui_size = dir->i_size;
738 dir->i_mtime = dir->i_ctime = inode->i_ctime;
739 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
740 if (err) {
741 ubifs_err("cannot create directory, error %d", err);
742 goto out_cancel;
743 }
744 mutex_unlock(&dir_ui->ui_mutex);
745
746 ubifs_release_budget(c, &req);
747 d_instantiate(dentry, inode);
748 return 0;
749
750out_cancel:
751 dir->i_size -= sz_change;
752 dir_ui->ui_size = dir->i_size;
753 drop_nlink(dir);
754 mutex_unlock(&dir_ui->ui_mutex);
755 make_bad_inode(inode);
756 iput(inode);
757out_budg:
758 ubifs_release_budget(c, &req);
759 return err;
760}
761
762static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
763 umode_t mode, dev_t rdev)
764{
765 struct inode *inode;
766 struct ubifs_inode *ui;
767 struct ubifs_inode *dir_ui = ubifs_inode(dir);
768 struct ubifs_info *c = dir->i_sb->s_fs_info;
769 union ubifs_dev_desc *dev = NULL;
770 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
771 int err, devlen = 0;
772 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
773 .new_ino_d = ALIGN(devlen, 8),
774 .dirtied_ino = 1 };
775
776
777
778
779
780
781 dbg_gen("dent '%.*s' in dir ino %lu",
782 dentry->d_name.len, dentry->d_name.name, dir->i_ino);
783
784 if (!new_valid_dev(rdev))
785 return -EINVAL;
786
787 if (S_ISBLK(mode) || S_ISCHR(mode)) {
788 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
789 if (!dev)
790 return -ENOMEM;
791 devlen = ubifs_encode_dev(dev, rdev);
792 }
793
794 err = ubifs_budget_space(c, &req);
795 if (err) {
796 kfree(dev);
797 return err;
798 }
799
800 inode = ubifs_new_inode(c, dir, mode);
801 if (IS_ERR(inode)) {
802 kfree(dev);
803 err = PTR_ERR(inode);
804 goto out_budg;
805 }
806
807 init_special_inode(inode, inode->i_mode, rdev);
808 inode->i_size = ubifs_inode(inode)->ui_size = devlen;
809 ui = ubifs_inode(inode);
810 ui->data = dev;
811 ui->data_len = devlen;
812
813 mutex_lock(&dir_ui->ui_mutex);
814 dir->i_size += sz_change;
815 dir_ui->ui_size = dir->i_size;
816 dir->i_mtime = dir->i_ctime = inode->i_ctime;
817 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
818 if (err)
819 goto out_cancel;
820 mutex_unlock(&dir_ui->ui_mutex);
821
822 ubifs_release_budget(c, &req);
823 insert_inode_hash(inode);
824 d_instantiate(dentry, inode);
825 return 0;
826
827out_cancel:
828 dir->i_size -= sz_change;
829 dir_ui->ui_size = dir->i_size;
830 mutex_unlock(&dir_ui->ui_mutex);
831 make_bad_inode(inode);
832 iput(inode);
833out_budg:
834 ubifs_release_budget(c, &req);
835 return err;
836}
837
838static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
839 const char *symname)
840{
841 struct inode *inode;
842 struct ubifs_inode *ui;
843 struct ubifs_inode *dir_ui = ubifs_inode(dir);
844 struct ubifs_info *c = dir->i_sb->s_fs_info;
845 int err, len = strlen(symname);
846 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
847 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
848 .new_ino_d = ALIGN(len, 8),
849 .dirtied_ino = 1 };
850
851
852
853
854
855
856 dbg_gen("dent '%.*s', target '%s' in dir ino %lu", dentry->d_name.len,
857 dentry->d_name.name, symname, dir->i_ino);
858
859 if (len > UBIFS_MAX_INO_DATA)
860 return -ENAMETOOLONG;
861
862 err = ubifs_budget_space(c, &req);
863 if (err)
864 return err;
865
866 inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO);
867 if (IS_ERR(inode)) {
868 err = PTR_ERR(inode);
869 goto out_budg;
870 }
871
872 ui = ubifs_inode(inode);
873 ui->data = kmalloc(len + 1, GFP_NOFS);
874 if (!ui->data) {
875 err = -ENOMEM;
876 goto out_inode;
877 }
878
879 memcpy(ui->data, symname, len);
880 ((char *)ui->data)[len] = '\0';
881
882
883
884
885
886 ui->data_len = len;
887 inode->i_size = ubifs_inode(inode)->ui_size = len;
888
889 mutex_lock(&dir_ui->ui_mutex);
890 dir->i_size += sz_change;
891 dir_ui->ui_size = dir->i_size;
892 dir->i_mtime = dir->i_ctime = inode->i_ctime;
893 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
894 if (err)
895 goto out_cancel;
896 mutex_unlock(&dir_ui->ui_mutex);
897
898 ubifs_release_budget(c, &req);
899 insert_inode_hash(inode);
900 d_instantiate(dentry, inode);
901 return 0;
902
903out_cancel:
904 dir->i_size -= sz_change;
905 dir_ui->ui_size = dir->i_size;
906 mutex_unlock(&dir_ui->ui_mutex);
907out_inode:
908 make_bad_inode(inode);
909 iput(inode);
910out_budg:
911 ubifs_release_budget(c, &req);
912 return err;
913}
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
929 struct inode *inode3)
930{
931 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
932 if (inode2 != inode1)
933 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
934 if (inode3)
935 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
936}
937
938
939
940
941
942
943
944static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
945 struct inode *inode3)
946{
947 if (inode3)
948 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
949 if (inode1 != inode2)
950 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
951 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
952}
953
954static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
955 struct inode *new_dir, struct dentry *new_dentry)
956{
957 struct ubifs_info *c = old_dir->i_sb->s_fs_info;
958 struct inode *old_inode = old_dentry->d_inode;
959 struct inode *new_inode = new_dentry->d_inode;
960 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
961 int err, release, sync = 0, move = (new_dir != old_dir);
962 int is_dir = S_ISDIR(old_inode->i_mode);
963 int unlink = !!new_inode;
964 int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
965 int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
966 struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
967 .dirtied_ino = 3 };
968 struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
969 .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
970 struct timespec time;
971 unsigned int uninitialized_var(saved_nlink);
972
973
974
975
976
977
978
979
980
981
982 dbg_gen("dent '%.*s' ino %lu in dir ino %lu to dent '%.*s' in dir ino %lu",
983 old_dentry->d_name.len, old_dentry->d_name.name,
984 old_inode->i_ino, old_dir->i_ino, new_dentry->d_name.len,
985 new_dentry->d_name.name, new_dir->i_ino);
986 ubifs_assert(mutex_is_locked(&old_dir->i_mutex));
987 ubifs_assert(mutex_is_locked(&new_dir->i_mutex));
988 if (unlink)
989 ubifs_assert(mutex_is_locked(&new_inode->i_mutex));
990
991
992 if (unlink && is_dir) {
993 err = check_dir_empty(c, new_inode);
994 if (err)
995 return err;
996 }
997
998 err = ubifs_budget_space(c, &req);
999 if (err)
1000 return err;
1001 err = ubifs_budget_space(c, &ino_req);
1002 if (err) {
1003 ubifs_release_budget(c, &req);
1004 return err;
1005 }
1006
1007 lock_3_inodes(old_dir, new_dir, new_inode);
1008
1009
1010
1011
1012
1013 time = ubifs_current_time(old_dir);
1014 old_inode->i_ctime = time;
1015
1016
1017 if (is_dir) {
1018 if (move) {
1019
1020
1021
1022
1023 drop_nlink(old_dir);
1024
1025
1026
1027
1028 if (!unlink)
1029 inc_nlink(new_dir);
1030 } else {
1031
1032
1033
1034
1035
1036 if (unlink)
1037 drop_nlink(old_dir);
1038 }
1039 }
1040
1041 old_dir->i_size -= old_sz;
1042 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1043 old_dir->i_mtime = old_dir->i_ctime = time;
1044 new_dir->i_mtime = new_dir->i_ctime = time;
1045
1046
1047
1048
1049
1050
1051 if (unlink) {
1052
1053
1054
1055
1056 saved_nlink = new_inode->i_nlink;
1057 if (is_dir)
1058 clear_nlink(new_inode);
1059 else
1060 drop_nlink(new_inode);
1061 new_inode->i_ctime = time;
1062 } else {
1063 new_dir->i_size += new_sz;
1064 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1065 }
1066
1067
1068
1069
1070
1071
1072 if (IS_SYNC(old_inode)) {
1073 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1074 if (unlink && IS_SYNC(new_inode))
1075 sync = 1;
1076 }
1077 err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1078 sync);
1079 if (err)
1080 goto out_cancel;
1081
1082 unlock_3_inodes(old_dir, new_dir, new_inode);
1083 ubifs_release_budget(c, &req);
1084
1085 mutex_lock(&old_inode_ui->ui_mutex);
1086 release = old_inode_ui->dirty;
1087 mark_inode_dirty_sync(old_inode);
1088 mutex_unlock(&old_inode_ui->ui_mutex);
1089
1090 if (release)
1091 ubifs_release_budget(c, &ino_req);
1092 if (IS_SYNC(old_inode))
1093 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1094 return err;
1095
1096out_cancel:
1097 if (unlink) {
1098 set_nlink(new_inode, saved_nlink);
1099 } else {
1100 new_dir->i_size -= new_sz;
1101 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1102 }
1103 old_dir->i_size += old_sz;
1104 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1105 if (is_dir) {
1106 if (move) {
1107 inc_nlink(old_dir);
1108 if (!unlink)
1109 drop_nlink(new_dir);
1110 } else {
1111 if (unlink)
1112 inc_nlink(old_dir);
1113 }
1114 }
1115 unlock_3_inodes(old_dir, new_dir, new_inode);
1116 ubifs_release_budget(c, &ino_req);
1117 ubifs_release_budget(c, &req);
1118 return err;
1119}
1120
1121int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1122 struct kstat *stat)
1123{
1124 loff_t size;
1125 struct inode *inode = dentry->d_inode;
1126 struct ubifs_inode *ui = ubifs_inode(inode);
1127
1128 mutex_lock(&ui->ui_mutex);
1129 generic_fillattr(inode, stat);
1130 stat->blksize = UBIFS_BLOCK_SIZE;
1131 stat->size = ui->ui_size;
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145 if (S_ISREG(inode->i_mode)) {
1146 size = ui->xattr_size;
1147 size += stat->size;
1148 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1149
1150
1151
1152
1153 stat->blocks = size >> 9;
1154 } else
1155 stat->blocks = 0;
1156 mutex_unlock(&ui->ui_mutex);
1157 return 0;
1158}
1159
1160const struct inode_operations ubifs_dir_inode_operations = {
1161 .lookup = ubifs_lookup,
1162 .create = ubifs_create,
1163 .link = ubifs_link,
1164 .symlink = ubifs_symlink,
1165 .unlink = ubifs_unlink,
1166 .mkdir = ubifs_mkdir,
1167 .rmdir = ubifs_rmdir,
1168 .mknod = ubifs_mknod,
1169 .rename = ubifs_rename,
1170 .setattr = ubifs_setattr,
1171 .getattr = ubifs_getattr,
1172 .setxattr = ubifs_setxattr,
1173 .getxattr = ubifs_getxattr,
1174 .listxattr = ubifs_listxattr,
1175 .removexattr = ubifs_removexattr,
1176};
1177
1178const struct file_operations ubifs_dir_operations = {
1179 .llseek = generic_file_llseek,
1180 .release = ubifs_dir_release,
1181 .read = generic_read_dir,
1182 .iterate = ubifs_readdir,
1183 .fsync = ubifs_fsync,
1184 .unlocked_ioctl = ubifs_ioctl,
1185#ifdef CONFIG_COMPAT
1186 .compat_ioctl = ubifs_compat_ioctl,
1187#endif
1188};
1189