1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <linux/export.h> 3 #include <linux/sched/signal.h> 4 #include <linux/sched/task.h> 5 #include <linux/fs.h> 6 #include <linux/path.h> 7 #include <linux/slab.h> 8 #include <linux/fs_struct.h> 9 #include <linux/init_task.h> 10 #include "internal.h" 11 12 /* 13 * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values. 14 * It can block. 15 */ 16 void set_fs_root(struct fs_struct *fs, const struct path *path) 17 { 18 struct path old_root; 19 20 path_get(path); 21 write_seqlock(&fs->seq); 22 old_root = fs->root; 23 fs->root = *path; 24 write_sequnlock(&fs->seq); 25 if (old_root.dentry) 26 path_put(&old_root); 27 } 28 29 /* 30 * Replace the fs->{pwdmnt,pwd} with {mnt,dentry}. Put the old values. 31 * It can block. 32 */ 33 void set_fs_pwd(struct fs_struct *fs, const struct path *path) 34 { 35 struct path old_pwd; 36 37 path_get(path); 38 write_seqlock(&fs->seq); 39 old_pwd = fs->pwd; 40 fs->pwd = *path; 41 write_sequnlock(&fs->seq); 42 43 if (old_pwd.dentry) 44 path_put(&old_pwd); 45 } 46 47 static inline int replace_path(struct path *p, const struct path *old, const struct path *new) 48 { 49 if (likely(p->dentry != old->dentry || p->mnt != old->mnt)) 50 return 0; 51 *p = *new; 52 return 1; 53 } 54 55 void chroot_fs_refs(const struct path *old_root, const struct path *new_root) 56 { 57 struct task_struct *g, *p; 58 struct fs_struct *fs; 59 int count = 0; 60 61 read_lock(&tasklist_lock); 62 for_each_process_thread(g, p) { 63 task_lock(p); 64 fs = p->fs; 65 if (fs) { 66 int hits = 0; 67 write_seqlock(&fs->seq); 68 hits += replace_path(&fs->root, old_root, new_root); 69 hits += replace_path(&fs->pwd, old_root, new_root); 70 while (hits--) { 71 count++; 72 path_get(new_root); 73 } 74 write_sequnlock(&fs->seq); 75 } 76 task_unlock(p); 77 } 78 read_unlock(&tasklist_lock); 79 while (count--) 80 path_put(old_root); 81 } 82 83 void free_fs_struct(struct fs_struct *fs) 84 { 85 path_put(&fs->root); 86 path_put(&fs->pwd); 87 kmem_cache_free(fs_cachep, fs); 88 } 89 90 void exit_fs(struct task_struct *tsk) 91 { 92 struct fs_struct *fs = tsk->fs; 93 94 if (fs) { 95 int kill; 96 task_lock(tsk); 97 read_seqlock_excl(&fs->seq); 98 tsk->fs = NULL; 99 kill = !--fs->users; 100 read_sequnlock_excl(&fs->seq); 101 task_unlock(tsk); 102 if (kill) 103 free_fs_struct(fs); 104 } 105 } 106 107 struct fs_struct *copy_fs_struct(struct fs_struct *old) 108 { 109 struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL); 110 /* We don't need to lock fs - think why ;-) */ 111 if (fs) { 112 fs->users = 1; 113 fs->in_exec = 0; 114 seqlock_init(&fs->seq); 115 fs->umask = old->umask; 116 117 read_seqlock_excl(&old->seq); 118 fs->root = old->root; 119 path_get(&fs->root); 120 fs->pwd = old->pwd; 121 path_get(&fs->pwd); 122 read_sequnlock_excl(&old->seq); 123 } 124 return fs; 125 } 126 127 int unshare_fs_struct(void) 128 { 129 struct fs_struct *fs = current->fs; 130 struct fs_struct *new_fs = copy_fs_struct(fs); 131 int kill; 132 133 if (!new_fs) 134 return -ENOMEM; 135 136 task_lock(current); 137 read_seqlock_excl(&fs->seq); 138 kill = !--fs->users; 139 current->fs = new_fs; 140 read_sequnlock_excl(&fs->seq); 141 task_unlock(current); 142 143 if (kill) 144 free_fs_struct(fs); 145 146 return 0; 147 } 148 EXPORT_SYMBOL_GPL(unshare_fs_struct); 149 150 /* to be mentioned only in INIT_TASK */ 151 struct fs_struct init_fs = { 152 .users = 1, 153 .seq = __SEQLOCK_UNLOCKED(init_fs.seq), 154 .umask = 0022, 155 }; 156