inode.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  1. /*
  2. * inode.c - securityfs
  3. *
  4. * Copyright (C) 2005 Greg Kroah-Hartman <gregkh@suse.de>
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License version
  8. * 2 as published by the Free Software Foundation.
  9. *
  10. * Based on fs/debugfs/inode.c which had the following copyright notice:
  11. * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
  12. * Copyright (C) 2004 IBM Inc.
  13. */
  14. /* #define DEBUG */
  15. #include <linux/module.h>
  16. #include <linux/fs.h>
  17. #include <linux/mount.h>
  18. #include <linux/pagemap.h>
  19. #include <linux/init.h>
  20. #include <linux/namei.h>
  21. #include <linux/security.h>
  22. #define SECURITYFS_MAGIC 0x73636673
  23. static struct vfsmount *mount;
  24. static int mount_count;
  25. /*
  26. * TODO:
  27. * I think I can get rid of these default_file_ops, but not quite sure...
  28. */
  29. static ssize_t default_read_file(struct file *file, char __user *buf,
  30. size_t count, loff_t *ppos)
  31. {
  32. return 0;
  33. }
  34. static ssize_t default_write_file(struct file *file, const char __user *buf,
  35. size_t count, loff_t *ppos)
  36. {
  37. return count;
  38. }
  39. static int default_open(struct inode *inode, struct file *file)
  40. {
  41. if (inode->i_private)
  42. file->private_data = inode->i_private;
  43. return 0;
  44. }
  45. static const struct file_operations default_file_ops = {
  46. .read = default_read_file,
  47. .write = default_write_file,
  48. .open = default_open,
  49. };
  50. static struct inode *get_inode(struct super_block *sb, int mode, dev_t dev)
  51. {
  52. struct inode *inode = new_inode(sb);
  53. if (inode) {
  54. inode->i_mode = mode;
  55. inode->i_uid = 0;
  56. inode->i_gid = 0;
  57. inode->i_blocks = 0;
  58. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  59. switch (mode & S_IFMT) {
  60. default:
  61. init_special_inode(inode, mode, dev);
  62. break;
  63. case S_IFREG:
  64. inode->i_fop = &default_file_ops;
  65. break;
  66. case S_IFDIR:
  67. inode->i_op = &simple_dir_inode_operations;
  68. inode->i_fop = &simple_dir_operations;
  69. /* directory inodes start off with i_nlink == 2 (for "." entry) */
  70. inc_nlink(inode);
  71. break;
  72. }
  73. }
  74. return inode;
  75. }
  76. /* SMP-safe */
  77. static int mknod(struct inode *dir, struct dentry *dentry,
  78. int mode, dev_t dev)
  79. {
  80. struct inode *inode;
  81. int error = -EPERM;
  82. if (dentry->d_inode)
  83. return -EEXIST;
  84. inode = get_inode(dir->i_sb, mode, dev);
  85. if (inode) {
  86. d_instantiate(dentry, inode);
  87. dget(dentry);
  88. error = 0;
  89. }
  90. return error;
  91. }
  92. static int mkdir(struct inode *dir, struct dentry *dentry, int mode)
  93. {
  94. int res;
  95. mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
  96. res = mknod(dir, dentry, mode, 0);
  97. if (!res)
  98. inc_nlink(dir);
  99. return res;
  100. }
  101. static int create(struct inode *dir, struct dentry *dentry, int mode)
  102. {
  103. mode = (mode & S_IALLUGO) | S_IFREG;
  104. return mknod(dir, dentry, mode, 0);
  105. }
  106. static inline int positive(struct dentry *dentry)
  107. {
  108. return dentry->d_inode && !d_unhashed(dentry);
  109. }
  110. static int fill_super(struct super_block *sb, void *data, int silent)
  111. {
  112. static struct tree_descr files[] = {{""}};
  113. return simple_fill_super(sb, SECURITYFS_MAGIC, files);
  114. }
  115. static int get_sb(struct file_system_type *fs_type,
  116. int flags, const char *dev_name,
  117. void *data, struct vfsmount *mnt)
  118. {
  119. return get_sb_single(fs_type, flags, data, fill_super, mnt);
  120. }
  121. static struct file_system_type fs_type = {
  122. .owner = THIS_MODULE,
  123. .name = "securityfs",
  124. .get_sb = get_sb,
  125. .kill_sb = kill_litter_super,
  126. };
  127. static int create_by_name(const char *name, mode_t mode,
  128. struct dentry *parent,
  129. struct dentry **dentry)
  130. {
  131. int error = 0;
  132. *dentry = NULL;
  133. /* If the parent is not specified, we create it in the root.
  134. * We need the root dentry to do this, which is in the super
  135. * block. A pointer to that is in the struct vfsmount that we
  136. * have around.
  137. */
  138. if (!parent ) {
  139. if (mount && mount->mnt_sb) {
  140. parent = mount->mnt_sb->s_root;
  141. }
  142. }
  143. if (!parent) {
  144. pr_debug("securityfs: Ah! can not find a parent!\n");
  145. return -EFAULT;
  146. }
  147. mutex_lock(&parent->d_inode->i_mutex);
  148. *dentry = lookup_one_len(name, parent, strlen(name));
  149. if (!IS_ERR(dentry)) {
  150. if ((mode & S_IFMT) == S_IFDIR)
  151. error = mkdir(parent->d_inode, *dentry, mode);
  152. else
  153. error = create(parent->d_inode, *dentry, mode);
  154. } else
  155. error = PTR_ERR(dentry);
  156. mutex_unlock(&parent->d_inode->i_mutex);
  157. return error;
  158. }
  159. /**
  160. * securityfs_create_file - create a file in the securityfs filesystem
  161. *
  162. * @name: a pointer to a string containing the name of the file to create.
  163. * @mode: the permission that the file should have
  164. * @parent: a pointer to the parent dentry for this file. This should be a
  165. * directory dentry if set. If this paramater is NULL, then the
  166. * file will be created in the root of the securityfs filesystem.
  167. * @data: a pointer to something that the caller will want to get to later
  168. * on. The inode.i_private pointer will point to this value on
  169. * the open() call.
  170. * @fops: a pointer to a struct file_operations that should be used for
  171. * this file.
  172. *
  173. * This is the basic "create a file" function for securityfs. It allows for a
  174. * wide range of flexibility in createing a file, or a directory (if you
  175. * want to create a directory, the securityfs_create_dir() function is
  176. * recommended to be used instead.)
  177. *
  178. * This function will return a pointer to a dentry if it succeeds. This
  179. * pointer must be passed to the securityfs_remove() function when the file is
  180. * to be removed (no automatic cleanup happens if your module is unloaded,
  181. * you are responsible here.) If an error occurs, NULL will be returned.
  182. *
  183. * If securityfs is not enabled in the kernel, the value -ENODEV will be
  184. * returned. It is not wise to check for this value, but rather, check for
  185. * NULL or !NULL instead as to eliminate the need for #ifdef in the calling
  186. * code.
  187. */
  188. struct dentry *securityfs_create_file(const char *name, mode_t mode,
  189. struct dentry *parent, void *data,
  190. const struct file_operations *fops)
  191. {
  192. struct dentry *dentry = NULL;
  193. int error;
  194. pr_debug("securityfs: creating file '%s'\n",name);
  195. error = simple_pin_fs(&fs_type, &mount, &mount_count);
  196. if (error) {
  197. dentry = ERR_PTR(error);
  198. goto exit;
  199. }
  200. error = create_by_name(name, mode, parent, &dentry);
  201. if (error) {
  202. dentry = ERR_PTR(error);
  203. simple_release_fs(&mount, &mount_count);
  204. goto exit;
  205. }
  206. if (dentry->d_inode) {
  207. if (fops)
  208. dentry->d_inode->i_fop = fops;
  209. if (data)
  210. dentry->d_inode->i_private = data;
  211. }
  212. exit:
  213. return dentry;
  214. }
  215. EXPORT_SYMBOL_GPL(securityfs_create_file);
  216. /**
  217. * securityfs_create_dir - create a directory in the securityfs filesystem
  218. *
  219. * @name: a pointer to a string containing the name of the directory to
  220. * create.
  221. * @parent: a pointer to the parent dentry for this file. This should be a
  222. * directory dentry if set. If this paramater is NULL, then the
  223. * directory will be created in the root of the securityfs filesystem.
  224. *
  225. * This function creates a directory in securityfs with the given name.
  226. *
  227. * This function will return a pointer to a dentry if it succeeds. This
  228. * pointer must be passed to the securityfs_remove() function when the file is
  229. * to be removed (no automatic cleanup happens if your module is unloaded,
  230. * you are responsible here.) If an error occurs, NULL will be returned.
  231. *
  232. * If securityfs is not enabled in the kernel, the value -ENODEV will be
  233. * returned. It is not wise to check for this value, but rather, check for
  234. * NULL or !NULL instead as to eliminate the need for #ifdef in the calling
  235. * code.
  236. */
  237. struct dentry *securityfs_create_dir(const char *name, struct dentry *parent)
  238. {
  239. return securityfs_create_file(name,
  240. S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
  241. parent, NULL, NULL);
  242. }
  243. EXPORT_SYMBOL_GPL(securityfs_create_dir);
  244. /**
  245. * securityfs_remove - removes a file or directory from the securityfs filesystem
  246. *
  247. * @dentry: a pointer to a the dentry of the file or directory to be
  248. * removed.
  249. *
  250. * This function removes a file or directory in securityfs that was previously
  251. * created with a call to another securityfs function (like
  252. * securityfs_create_file() or variants thereof.)
  253. *
  254. * This function is required to be called in order for the file to be
  255. * removed, no automatic cleanup of files will happen when a module is
  256. * removed, you are responsible here.
  257. */
  258. void securityfs_remove(struct dentry *dentry)
  259. {
  260. struct dentry *parent;
  261. if (!dentry)
  262. return;
  263. parent = dentry->d_parent;
  264. if (!parent || !parent->d_inode)
  265. return;
  266. mutex_lock(&parent->d_inode->i_mutex);
  267. if (positive(dentry)) {
  268. if (dentry->d_inode) {
  269. if (S_ISDIR(dentry->d_inode->i_mode))
  270. simple_rmdir(parent->d_inode, dentry);
  271. else
  272. simple_unlink(parent->d_inode, dentry);
  273. dput(dentry);
  274. }
  275. }
  276. mutex_unlock(&parent->d_inode->i_mutex);
  277. simple_release_fs(&mount, &mount_count);
  278. }
  279. EXPORT_SYMBOL_GPL(securityfs_remove);
  280. static decl_subsys(security, NULL, NULL);
  281. static int __init securityfs_init(void)
  282. {
  283. int retval;
  284. kset_set_kset_s(&security_subsys, kernel_subsys);
  285. retval = subsystem_register(&security_subsys);
  286. if (retval)
  287. return retval;
  288. retval = register_filesystem(&fs_type);
  289. if (retval)
  290. subsystem_unregister(&security_subsys);
  291. return retval;
  292. }
  293. static void __exit securityfs_exit(void)
  294. {
  295. simple_release_fs(&mount, &mount_count);
  296. unregister_filesystem(&fs_type);
  297. subsystem_unregister(&security_subsys);
  298. }
  299. core_initcall(securityfs_init);
  300. module_exit(securityfs_exit);
  301. MODULE_LICENSE("GPL");