include/linux/fdtable.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * descriptor table internals; you almost certainly want file.h instead.
   4  */
   5
   6 #ifndef __LINUX_FDTABLE_H
   7 #define __LINUX_FDTABLE_H
   8
   9 #include <linux/posix_types.h>
  10 #include <linux/compiler.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/rcupdate.h>
  13 #include <linux/nospec.h>
  14 #include <linux/types.h>
  15 #include <linux/init.h>
  16 #include <linux/fs.h>
  17
  18 #include <linux/atomic.h>
  19
  20 /*
  21  * The default fd array needs to be at least BITS_PER_LONG,
  22  * as this is the granularity returned by copy_fdset().
  23  */
  24 #define NR_OPEN_DEFAULT BITS_PER_LONG
  25
  26 struct fdtable {
  27         unsigned int max_fds;
  28         struct file __rcu **fd;      /* current fd array */
  29         unsigned long *close_on_exec;
  30         unsigned long *open_fds;
  31         unsigned long *full_fds_bits;
  32         struct rcu_head rcu;
  33 };
  34
  35 /*
  36  * Open file table structure
  37  */
  38 struct files_struct {
  39   /*
  40    * read mostly part
  41    */
  42         atomic_t count;
  43         bool resize_in_progress;
  44         wait_queue_head_t resize_wait;
  45
  46         struct fdtable __rcu *fdt;
  47         struct fdtable fdtab;
  48   /*
  49    * written part on a separate cache line in SMP
  50    */
  51         spinlock_t file_lock ____cacheline_aligned_in_smp;
  52         unsigned int next_fd;
  53         unsigned long close_on_exec_init[1];
  54         unsigned long open_fds_init[1];
  55         unsigned long full_fds_bits_init[1];
  56         struct file __rcu * fd_array[NR_OPEN_DEFAULT];
  57 };
  58
  59 struct file_operations;
  60 struct vfsmount;
  61 struct dentry;
  62
  63 #define rcu_dereference_check_fdtable(files, fdtfd) \
  64         rcu_dereference_check((fdtfd), lockdep_is_held(&(files)->file_lock))
  65
  66 #define files_fdtable(files) \
  67         rcu_dereference_check_fdtable((files), (files)->fdt)
  68
  69 /*
  70  * The caller must ensure that fd table isn't shared or hold rcu or file lock
  71  */
  72 static inline struct file *files_lookup_fd_raw(struct files_struct *files, unsigned int fd)
  73 {
  74         struct fdtable *fdt = rcu_dereference_raw(files->fdt);
  75         unsigned long mask = array_index_mask_nospec(fd, fdt->max_fds);
  76         struct file *needs_masking;
  77
  78         /*
  79          * 'mask' is zero for an out-of-bounds fd, all ones for ok.
  80          * 'fd&mask' is 'fd' for ok, or 0 for out of bounds.
  81          *
  82          * Accessing fdt->fd[0] is ok, but needs masking of the result.
  83          */
  84         needs_masking = rcu_dereference_raw(fdt->fd[fd&mask]);
  85         return (struct file *)(mask & (unsigned long)needs_masking);
  86 }
  87
  88 static inline struct file *files_lookup_fd_locked(struct files_struct *files, unsigned int fd)
  89 {
  90         RCU_LOCKDEP_WARN(!lockdep_is_held(&files->file_lock),
  91                            "suspicious rcu_dereference_check() usage");
  92         return files_lookup_fd_raw(files, fd);
  93 }
  94
  95 static inline bool close_on_exec(unsigned int fd, const struct files_struct *files)
  96 {
  97         return test_bit(fd, files_fdtable(files)->close_on_exec);
  98 }
  99
 100 struct task_struct;
 101
 102 void put_files_struct(struct files_struct *fs);
 103 int unshare_files(void);
 104 struct fd_range {
 105         unsigned int from, to;
 106 };
 107 struct files_struct *dup_fd(struct files_struct *, struct fd_range *) __latent_entropy;
 108 void do_close_on_exec(struct files_struct *);
 109 int iterate_fd(struct files_struct *, unsigned,
 110                 int (*)(const void *, struct file *, unsigned),
 111                 const void *);
 112
 113 extern int close_fd(unsigned int fd);
 114 extern struct file *file_close_fd(unsigned int fd);
 115
 116 extern struct kmem_cache *files_cachep;
 117
 118 #endif /* __LINUX_FDTABLE_H */