1 /* 2 * devtmpfs - kernel-maintained tmpfs-based /dev 3 * 4 * Copyright (C) 2009, Kay Sievers <kay.sievers@vrfy.org> 5 * 6 * During bootup, before any driver core device is registered, 7 * devtmpfs, a tmpfs-based filesystem is created. Every driver-core 8 * device which requests a device node, will add a node in this 9 * filesystem. 10 * By default, all devices are named after the name of the device, 11 * owned by root and have a default mode of 0600. Subsystems can 12 * overwrite the default setting if needed. 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/syscalls.h> 17 #include <linux/mount.h> 18 #include <linux/device.h> 19 #include <linux/genhd.h> 20 #include <linux/namei.h> 21 #include <linux/fs.h> 22 #include <linux/shmem_fs.h> 23 #include <linux/ramfs.h> 24 #include <linux/sched.h> 25 #include <linux/slab.h> 26 #include <linux/kthread.h> 27 28 static struct task_struct *thread; 29 30 #if defined CONFIG_DEVTMPFS_MOUNT 31 static int mount_dev = 1; 32 #else 33 static int mount_dev; 34 #endif 35 36 static DEFINE_SPINLOCK(req_lock); 37 38 static struct req { 39 struct req *next; 40 struct completion done; 41 int err; 42 const char *name; 43 umode_t mode; /* 0 => delete */ 44 struct device *dev; 45 } *requests; 46 47 static int __init mount_param(char *str) 48 { 49 mount_dev = simple_strtoul(str, NULL, 0); 50 return 1; 51 } 52 __setup("devtmpfs.mount=", mount_param); 53 54 static struct dentry *dev_mount(struct file_system_type *fs_type, int flags, 55 const char *dev_name, void *data) 56 { 57 #ifdef CONFIG_TMPFS 58 return mount_single(fs_type, flags, data, shmem_fill_super); 59 #else 60 return mount_single(fs_type, flags, data, ramfs_fill_super); 61 #endif 62 } 63 64 static struct file_system_type dev_fs_type = { 65 .name = "devtmpfs", 66 .mount = dev_mount, 67 .kill_sb = kill_litter_super, 68 }; 69 70 #ifdef CONFIG_BLOCK 71 static inline int is_blockdev(struct device *dev) 72 { 73 return dev->class == &block_class; 74 } 75 #else 76 static inline int is_blockdev(struct device *dev) { return 0; } 77 #endif 78 79 int devtmpfs_create_node(struct device *dev) 80 { 81 const char *tmp = NULL; 82 struct req req; 83 84 if (!thread) 85 return 0; 86 87 req.mode = 0; 88 req.name = device_get_devnode(dev, &req.mode, &tmp); 89 if (!req.name) 90 return -ENOMEM; 91 92 if (req.mode == 0) 93 req.mode = 0600; 94 if (is_blockdev(dev)) 95 req.mode |= S_IFBLK; 96 else 97 req.mode |= S_IFCHR; 98 99 req.dev = dev; 100 101 init_completion(&req.done); 102 103 spin_lock(&req_lock); 104 req.next = requests; 105 requests = &req; 106 spin_unlock(&req_lock); 107 108 wake_up_process(thread); 109 wait_for_completion(&req.done); 110 111 kfree(tmp); 112 113 return req.err; 114 } 115 116 int devtmpfs_delete_node(struct device *dev) 117 { 118 const char *tmp = NULL; 119 struct req req; 120 121 if (!thread) 122 return 0; 123 124 req.name = device_get_devnode(dev, NULL, &tmp); 125 if (!req.name) 126 return -ENOMEM; 127 128 req.mode = 0; 129 req.dev = dev; 130 131 init_completion(&req.done); 132 133 spin_lock(&req_lock); 134 req.next = requests; 135 requests = &req; 136 spin_unlock(&req_lock); 137 138 wake_up_process(thread); 139 wait_for_completion(&req.done); 140 141 kfree(tmp); 142 return req.err; 143 } 144 145 static int dev_mkdir(const char *name, umode_t mode) 146 { 147 struct dentry *dentry; 148 struct path path; 149 int err; 150 151 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); 152 if (IS_ERR(dentry)) 153 return PTR_ERR(dentry); 154 155 err = vfs_mkdir(path.dentry->d_inode, dentry, mode); 156 if (!err) 157 /* mark as kernel-created inode */ 158 dentry->d_inode->i_private = &thread; 159 done_path_create(&path, dentry); 160 return err; 161 } 162 163 static int create_path(const char *nodepath) 164 { 165 char *path; 166 char *s; 167 int err = 0; 168 169 /* parent directories do not exist, create them */ 170 path = kstrdup(nodepath, GFP_KERNEL); 171 if (!path) 172 return -ENOMEM; 173 174 s = path; 175 for (;;) { 176 s = strchr(s, '/'); 177 if (!s) 178 break; 179 s[0] = '\0'; 180 err = dev_mkdir(path, 0755); 181 if (err && err != -EEXIST) 182 break; 183 s[0] = '/'; 184 s++; 185 } 186 kfree(path); 187 return err; 188 } 189 190 static int handle_create(const char *nodename, umode_t mode, struct device *dev) 191 { 192 struct dentry *dentry; 193 struct path path; 194 int err; 195 196 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); 197 if (dentry == ERR_PTR(-ENOENT)) { 198 create_path(nodename); 199 dentry = kern_path_create(AT_FDCWD, nodename, &path, 0); 200 } 201 if (IS_ERR(dentry)) 202 return PTR_ERR(dentry); 203 204 err = vfs_mknod(path.dentry->d_inode, 205 dentry, mode, dev->devt); 206 if (!err) { 207 struct iattr newattrs; 208 209 /* fixup possibly umasked mode */ 210 newattrs.ia_mode = mode; 211 newattrs.ia_valid = ATTR_MODE; 212 mutex_lock(&dentry->d_inode->i_mutex); 213 notify_change(dentry, &newattrs); 214 mutex_unlock(&dentry->d_inode->i_mutex); 215 216 /* mark as kernel-created inode */ 217 dentry->d_inode->i_private = &thread; 218 } 219 done_path_create(&path, dentry); 220 return err; 221 } 222 223 static int dev_rmdir(const char *name) 224 { 225 struct path parent; 226 struct dentry *dentry; 227 int err; 228 229 dentry = kern_path_locked(name, &parent); 230 if (IS_ERR(dentry)) 231 return PTR_ERR(dentry); 232 if (dentry->d_inode) { 233 if (dentry->d_inode->i_private == &thread) 234 err = vfs_rmdir(parent.dentry->d_inode, dentry); 235 else 236 err = -EPERM; 237 } else { 238 err = -ENOENT; 239 } 240 dput(dentry); 241 mutex_unlock(&parent.dentry->d_inode->i_mutex); 242 path_put(&parent); 243 return err; 244 } 245 246 static int delete_path(const char *nodepath) 247 { 248 const char *path; 249 int err = 0; 250 251 path = kstrdup(nodepath, GFP_KERNEL); 252 if (!path) 253 return -ENOMEM; 254 255 for (;;) { 256 char *base; 257 258 base = strrchr(path, '/'); 259 if (!base) 260 break; 261 base[0] = '\0'; 262 err = dev_rmdir(path); 263 if (err) 264 break; 265 } 266 267 kfree(path); 268 return err; 269 } 270 271 static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat) 272 { 273 /* did we create it */ 274 if (inode->i_private != &thread) 275 return 0; 276 277 /* does the dev_t match */ 278 if (is_blockdev(dev)) { 279 if (!S_ISBLK(stat->mode)) 280 return 0; 281 } else { 282 if (!S_ISCHR(stat->mode)) 283 return 0; 284 } 285 if (stat->rdev != dev->devt) 286 return 0; 287 288 /* ours */ 289 return 1; 290 } 291 292 static int handle_remove(const char *nodename, struct device *dev) 293 { 294 struct path parent; 295 struct dentry *dentry; 296 int deleted = 1; 297 int err; 298 299 dentry = kern_path_locked(nodename, &parent); 300 if (IS_ERR(dentry)) 301 return PTR_ERR(dentry); 302 303 if (dentry->d_inode) { 304 struct kstat stat; 305 struct path p = {.mnt = parent.mnt, .dentry = dentry}; 306 err = vfs_getattr(&p, &stat); 307 if (!err && dev_mynode(dev, dentry->d_inode, &stat)) { 308 struct iattr newattrs; 309 /* 310 * before unlinking this node, reset permissions 311 * of possible references like hardlinks 312 */ 313 newattrs.ia_uid = GLOBAL_ROOT_UID; 314 newattrs.ia_gid = GLOBAL_ROOT_GID; 315 newattrs.ia_mode = stat.mode & ~0777; 316 newattrs.ia_valid = 317 ATTR_UID|ATTR_GID|ATTR_MODE; 318 mutex_lock(&dentry->d_inode->i_mutex); 319 notify_change(dentry, &newattrs); 320 mutex_unlock(&dentry->d_inode->i_mutex); 321 err = vfs_unlink(parent.dentry->d_inode, dentry); 322 if (!err || err == -ENOENT) 323 deleted = 1; 324 } 325 } else { 326 err = -ENOENT; 327 } 328 dput(dentry); 329 mutex_unlock(&parent.dentry->d_inode->i_mutex); 330 331 path_put(&parent); 332 if (deleted && strchr(nodename, '/')) 333 delete_path(nodename); 334 return err; 335 } 336 337 /* 338 * If configured, or requested by the commandline, devtmpfs will be 339 * auto-mounted after the kernel mounted the root filesystem. 340 */ 341 int devtmpfs_mount(const char *mntdir) 342 { 343 int err; 344 345 if (!mount_dev) 346 return 0; 347 348 if (!thread) 349 return 0; 350 351 err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL); 352 if (err) 353 printk(KERN_INFO "devtmpfs: error mounting %i\n", err); 354 else 355 printk(KERN_INFO "devtmpfs: mounted\n"); 356 return err; 357 } 358 359 static DECLARE_COMPLETION(setup_done); 360 361 static int handle(const char *name, umode_t mode, struct device *dev) 362 { 363 if (mode) 364 return handle_create(name, mode, dev); 365 else 366 return handle_remove(name, dev); 367 } 368 369 static int devtmpfsd(void *p) 370 { 371 char options[] = "mode=0755"; 372 int *err = p; 373 *err = sys_unshare(CLONE_NEWNS); 374 if (*err) 375 goto out; 376 *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options); 377 if (*err) 378 goto out; 379 sys_chdir("/.."); /* will traverse into overmounted root */ 380 sys_chroot("."); 381 complete(&setup_done); 382 while (1) { 383 spin_lock(&req_lock); 384 while (requests) { 385 struct req *req = requests; 386 requests = NULL; 387 spin_unlock(&req_lock); 388 while (req) { 389 struct req *next = req->next; 390 req->err = handle(req->name, req->mode, req->dev); 391 complete(&req->done); 392 req = next; 393 } 394 spin_lock(&req_lock); 395 } 396 __set_current_state(TASK_INTERRUPTIBLE); 397 spin_unlock(&req_lock); 398 schedule(); 399 } 400 return 0; 401 out: 402 complete(&setup_done); 403 return *err; 404 } 405 406 /* 407 * Create devtmpfs instance, driver-core devices will add their device 408 * nodes here. 409 */ 410 int __init devtmpfs_init(void) 411 { 412 int err = register_filesystem(&dev_fs_type); 413 if (err) { 414 printk(KERN_ERR "devtmpfs: unable to register devtmpfs " 415 "type %i\n", err); 416 return err; 417 } 418 419 thread = kthread_run(devtmpfsd, &err, "kdevtmpfs"); 420 if (!IS_ERR(thread)) { 421 wait_for_completion(&setup_done); 422 } else { 423 err = PTR_ERR(thread); 424 thread = NULL; 425 } 426 427 if (err) { 428 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); 429 unregister_filesystem(&dev_fs_type); 430 return err; 431 } 432 433 printk(KERN_INFO "devtmpfs: initialized\n"); 434 return 0; 435 } 436