1/* 2 * linux/fs/file_table.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) 6 */ 7 8#include <linux/string.h> 9#include <linux/slab.h> 10#include <linux/file.h> 11#include <linux/fdtable.h> 12#include <linux/init.h> 13#include <linux/module.h> 14#include <linux/fs.h> 15#include <linux/security.h> 16#include <linux/eventpoll.h> 17#include <linux/rcupdate.h> 18#include <linux/mount.h> 19#include <linux/capability.h> 20#include <linux/cdev.h> 21#include <linux/fsnotify.h> 22#include <linux/sysctl.h> 23#include <linux/lglock.h> 24#include <linux/percpu_counter.h> 25#include <linux/percpu.h> 26#include <linux/ima.h> 27 28#include <asm/atomic.h> 29 30#include "internal.h" 31 32/* sysctl tunables... */ 33struct files_stat_struct files_stat = { 34 .max_files = NR_FILE 35}; 36 37DECLARE_LGLOCK(files_lglock); 38DEFINE_LGLOCK(files_lglock); 39 40/* SLAB cache for file structures */ 41static struct kmem_cache *filp_cachep __read_mostly; 42 43static struct percpu_counter nr_files __cacheline_aligned_in_smp; 44 45static inline void file_free_rcu(struct rcu_head *head) 46{ 47 struct file *f = container_of(head, struct file, f_u.fu_rcuhead); 48 49 put_cred(f->f_cred); 50 kmem_cache_free(filp_cachep, f); 51} 52 53static inline void file_free(struct file *f) 54{ 55 percpu_counter_dec(&nr_files); 56 file_check_state(f); 57 call_rcu(&f->f_u.fu_rcuhead, file_free_rcu); 58} 59 60/* 61 * Return the total number of open files in the system 62 */ 63static int get_nr_files(void) 64{ 65 return percpu_counter_read_positive(&nr_files); 66} 67 68/* 69 * Return the maximum number of open files in the system 70 */ 71int get_max_files(void) 72{ 73 return files_stat.max_files; 74} 75EXPORT_SYMBOL_GPL(get_max_files); 76 77/* 78 * Handle nr_files sysctl 79 */ 80#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS) 81int proc_nr_files(ctl_table *table, int write, 82 void __user *buffer, size_t *lenp, loff_t *ppos) 83{ 84 files_stat.nr_files = get_nr_files(); 85 return proc_dointvec(table, write, buffer, lenp, ppos); 86} 87#else 88int proc_nr_files(ctl_table *table, int write, 89 void __user *buffer, size_t *lenp, loff_t *ppos) 90{ 91 return -ENOSYS; 92} 93#endif 94 95/* Find an unused file structure and return a pointer to it. 96 * Returns NULL, if there are no more free file structures or 97 * we run out of memory. 98 * 99 * Be very careful using this. You are responsible for 100 * getting write access to any mount that you might assign 101 * to this filp, if it is opened for write. If this is not 102 * done, you will imbalance int the mount's writer count 103 * and a warning at __fput() time. 104 */ 105struct file *get_empty_filp(void) 106{ 107 const struct cred *cred = current_cred(); 108 static int old_max; 109 struct file * f; 110 111 /* 112 * Privileged users can go above max_files 113 */ 114 if (get_nr_files() >= files_stat.max_files && !capable(CAP_SYS_ADMIN)) { 115 /* 116 * percpu_counters are inaccurate. Do an expensive check before 117 * we go and fail. 118 */ 119 if (percpu_counter_sum_positive(&nr_files) >= files_stat.max_files) 120 goto over; 121 } 122 123 f = kmem_cache_zalloc(filp_cachep, GFP_KERNEL); 124 if (f == NULL) 125 goto fail; 126 127 percpu_counter_inc(&nr_files); 128 if (security_file_alloc(f)) 129 goto fail_sec; 130 131 INIT_LIST_HEAD(&f->f_u.fu_list); 132 atomic_long_set(&f->f_count, 1); 133 rwlock_init(&f->f_owner.lock); 134 f->f_cred = get_cred(cred); 135 spin_lock_init(&f->f_lock); 136 eventpoll_init_file(f); 137 /* f->f_version: 0 */ 138 return f; 139 140over: 141 /* Ran out of filps - report that */ 142 if (get_nr_files() > old_max) { 143 printk(KERN_INFO "VFS: file-max limit %d reached\n", 144 get_max_files()); 145 old_max = get_nr_files(); 146 } 147 goto fail; 148 149fail_sec: 150 file_free(f); 151fail: 152 return NULL; 153} 154 155/** 156 * alloc_file - allocate and initialize a 'struct file' 157 * @mnt: the vfsmount on which the file will reside 158 * @dentry: the dentry representing the new file 159 * @mode: the mode with which the new file will be opened 160 * @fop: the 'struct file_operations' for the new file 161 * 162 * Use this instead of get_empty_filp() to get a new 163 * 'struct file'. Do so because of the same initialization 164 * pitfalls reasons listed for init_file(). This is a 165 * preferred interface to using init_file(). 166 * 167 * If all the callers of init_file() are eliminated, its 168 * code should be moved into this function. 169 */ 170struct file *alloc_file(struct path *path, fmode_t mode, 171 const struct file_operations *fop) 172{ 173 struct file *file; 174 175 file = get_empty_filp(); 176 if (!file) 177 return NULL; 178 179 file->f_path = *path; 180 file->f_mapping = path->dentry->d_inode->i_mapping; 181 file->f_mode = mode; 182 file->f_op = fop; 183 184 /* 185 * These mounts don't really matter in practice 186 * for r/o bind mounts. They aren't userspace- 187 * visible. We do this for consistency, and so 188 * that we can do debugging checks at __fput() 189 */ 190 if ((mode & FMODE_WRITE) && !special_file(path->dentry->d_inode->i_mode)) { 191 file_take_write(file); 192 WARN_ON(mnt_clone_write(path->mnt)); 193 } 194 ima_counts_get(file); 195 return file; 196} 197EXPORT_SYMBOL(alloc_file); 198 199/** 200 * drop_file_write_access - give up ability to write to a file 201 * @file: the file to which we will stop writing 202 * 203 * This is a central place which will give up the ability 204 * to write to @file, along with access to write through 205 * its vfsmount. 206 */ 207void drop_file_write_access(struct file *file) 208{ 209 struct vfsmount *mnt = file->f_path.mnt; 210 struct dentry *dentry = file->f_path.dentry; 211 struct inode *inode = dentry->d_inode; 212 213 put_write_access(inode); 214 215 if (special_file(inode->i_mode)) 216 return; 217 if (file_check_writeable(file) != 0) 218 return; 219 mnt_drop_write(mnt); 220 file_release_write(file); 221} 222EXPORT_SYMBOL_GPL(drop_file_write_access); 223 224/* the real guts of fput() - releasing the last reference to file 225 */ 226static void __fput(struct file *file) 227{ 228 struct dentry *dentry = file->f_path.dentry; 229 struct vfsmount *mnt = file->f_path.mnt; 230 struct inode *inode = dentry->d_inode; 231 232 might_sleep(); 233 234 fsnotify_close(file); 235 /* 236 * The function eventpoll_release() should be the first called 237 * in the file cleanup chain. 238 */ 239 eventpoll_release(file); 240 locks_remove_flock(file); 241 242 if (unlikely(file->f_flags & FASYNC)) { 243 if (file->f_op && file->f_op->fasync) 244 file->f_op->fasync(-1, file, 0); 245 } 246 if (file->f_op && file->f_op->release) 247 file->f_op->release(inode, file); 248 security_file_free(file); 249 ima_file_free(file); 250 if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL)) 251 cdev_put(inode->i_cdev); 252 fops_put(file->f_op); 253 put_pid(file->f_owner.pid); 254 file_sb_list_del(file); 255 if (file->f_mode & FMODE_WRITE) 256 drop_file_write_access(file); 257 file->f_path.dentry = NULL; 258 file->f_path.mnt = NULL; 259 file_free(file); 260 dput(dentry); 261 mntput(mnt); 262} 263 264void fput(struct file *file) 265{ 266 if (atomic_long_dec_and_test(&file->f_count)) 267 __fput(file); 268} 269 270EXPORT_SYMBOL(fput); 271 272struct file *fget(unsigned int fd) 273{ 274 struct file *file; 275 struct files_struct *files = current->files; 276 277 rcu_read_lock(); 278 file = fcheck_files(files, fd); 279 if (file) { 280 if (!atomic_long_inc_not_zero(&file->f_count)) { 281 /* File object ref couldn't be taken */ 282 rcu_read_unlock(); 283 return NULL; 284 } 285 } 286 rcu_read_unlock(); 287 288 return file; 289} 290 291EXPORT_SYMBOL(fget); 292 293/* 294 * Lightweight file lookup - no refcnt increment if fd table isn't shared. 295 * 296 * You can use this instead of fget if you satisfy all of the following 297 * conditions: 298 * 1) You must call fput_light before exiting the syscall and returning control 299 * to userspace (i.e. you cannot remember the returned struct file * after 300 * returning to userspace). 301 * 2) You must not call filp_close on the returned struct file * in between 302 * calls to fget_light and fput_light. 303 * 3) You must not clone the current task in between the calls to fget_light 304 * and fput_light. 305 * 306 * The fput_needed flag returned by fget_light should be passed to the 307 * corresponding fput_light. 308 */ 309struct file *fget_light(unsigned int fd, int *fput_needed) 310{ 311 struct file *file; 312 struct files_struct *files = current->files; 313 314 *fput_needed = 0; 315 if (likely((atomic_read(&files->count) == 1))) { 316 file = fcheck_files(files, fd); 317 } else { 318 rcu_read_lock(); 319 file = fcheck_files(files, fd); 320 if (file) { 321 if (atomic_long_inc_not_zero(&file->f_count)) 322 *fput_needed = 1; 323 else 324 /* Didn't get the reference, someone's freed */ 325 file = NULL; 326 } 327 rcu_read_unlock(); 328 } 329 330 return file; 331} 332 333void put_filp(struct file *file) 334{ 335 if (atomic_long_dec_and_test(&file->f_count)) { 336 security_file_free(file); 337 file_sb_list_del(file); 338 file_free(file); 339 } 340} 341 342static inline int file_list_cpu(struct file *file) 343{ 344#ifdef CONFIG_SMP 345 return file->f_sb_list_cpu; 346#else 347 return smp_processor_id(); 348#endif 349} 350 351/* helper for file_sb_list_add to reduce ifdefs */ 352static inline void __file_sb_list_add(struct file *file, struct super_block *sb) 353{ 354 struct list_head *list; 355#ifdef CONFIG_SMP 356 int cpu; 357 cpu = smp_processor_id(); 358 file->f_sb_list_cpu = cpu; 359 list = per_cpu_ptr(sb->s_files, cpu); 360#else 361 list = &sb->s_files; 362#endif 363 list_add(&file->f_u.fu_list, list); 364} 365 366/** 367 * file_sb_list_add - add a file to the sb's file list 368 * @file: file to add 369 * @sb: sb to add it to 370 * 371 * Use this function to associate a file with the superblock of the inode it 372 * refers to. 373 */ 374void file_sb_list_add(struct file *file, struct super_block *sb) 375{ 376 lg_local_lock(files_lglock); 377 __file_sb_list_add(file, sb); 378 lg_local_unlock(files_lglock); 379} 380 381/** 382 * file_sb_list_del - remove a file from the sb's file list 383 * @file: file to remove 384 * @sb: sb to remove it from 385 * 386 * Use this function to remove a file from its superblock. 387 */ 388void file_sb_list_del(struct file *file) 389{ 390 if (!list_empty(&file->f_u.fu_list)) { 391 lg_local_lock_cpu(files_lglock, file_list_cpu(file)); 392 list_del_init(&file->f_u.fu_list); 393 lg_local_unlock_cpu(files_lglock, file_list_cpu(file)); 394 } 395} 396 397#ifdef CONFIG_SMP 398 399/* 400 * These macros iterate all files on all CPUs for a given superblock. 401 * files_lglock must be held globally. 402 */ 403#define do_file_list_for_each_entry(__sb, __file) \ 404{ \ 405 int i; \ 406 for_each_possible_cpu(i) { \ 407 struct list_head *list; \ 408 list = per_cpu_ptr((__sb)->s_files, i); \ 409 list_for_each_entry((__file), list, f_u.fu_list) 410 411#define while_file_list_for_each_entry \ 412 } \ 413} 414 415#else 416 417#define do_file_list_for_each_entry(__sb, __file) \ 418{ \ 419 struct list_head *list; \ 420 list = &(sb)->s_files; \ 421 list_for_each_entry((__file), list, f_u.fu_list) 422 423#define while_file_list_for_each_entry \ 424} 425 426#endif 427 428int fs_may_remount_ro(struct super_block *sb) 429{ 430 struct file *file; 431 /* Check that no files are currently opened for writing. */ 432 lg_global_lock(files_lglock); 433 do_file_list_for_each_entry(sb, file) { 434 struct inode *inode = file->f_path.dentry->d_inode; 435 436 /* File with pending delete? */ 437 if (inode->i_nlink == 0) 438 goto too_bad; 439 440 /* Writeable file? */ 441 if (S_ISREG(inode->i_mode) && (file->f_mode & FMODE_WRITE)) 442 goto too_bad; 443 } while_file_list_for_each_entry; 444 lg_global_unlock(files_lglock); 445 return 1; /* Tis' cool bro. */ 446too_bad: 447 lg_global_unlock(files_lglock); 448 return 0; 449} 450 451/** 452 * mark_files_ro - mark all files read-only 453 * @sb: superblock in question 454 * 455 * All files are marked read-only. We don't care about pending 456 * delete files so this should be used in 'force' mode only. 457 */ 458void mark_files_ro(struct super_block *sb) 459{ 460 struct file *f; 461 462retry: 463 lg_global_lock(files_lglock); 464 do_file_list_for_each_entry(sb, f) { 465 struct vfsmount *mnt; 466 if (!S_ISREG(f->f_path.dentry->d_inode->i_mode)) 467 continue; 468 if (!file_count(f)) 469 continue; 470 if (!(f->f_mode & FMODE_WRITE)) 471 continue; 472 spin_lock(&f->f_lock); 473 f->f_mode &= ~FMODE_WRITE; 474 spin_unlock(&f->f_lock); 475 if (file_check_writeable(f) != 0) 476 continue; 477 file_release_write(f); 478 mnt = mntget(f->f_path.mnt); 479 /* This can sleep, so we can't hold the spinlock. */ 480 lg_global_unlock(files_lglock); 481 mnt_drop_write(mnt); 482 mntput(mnt); 483 goto retry; 484 } while_file_list_for_each_entry; 485 lg_global_unlock(files_lglock); 486} 487 488void __init files_init(unsigned long mempages) 489{ 490 int n; 491 492 filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0, 493 SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL); 494 495 /* 496 * One file with associated inode and dcache is very roughly 1K. 497 * Per default don't use more than 10% of our memory for files. 498 */ 499 500 n = (mempages * (PAGE_SIZE / 1024)) / 10; 501 files_stat.max_files = n; 502 if (files_stat.max_files < NR_FILE) 503 files_stat.max_files = NR_FILE; 504 files_defer_init(); 505 lg_lock_init(files_lglock); 506 percpu_counter_init(&nr_files, 0); 507} 508