include/linux/file.h

   1 /*
   2  * Wrapper functions for accessing the file_struct fd array.
   3  */
   4
   5 #ifndef __LINUX_FILE_H
   6 #define __LINUX_FILE_H
   7
   8 extern void _fput(struct file *);
   9
  10 static inline struct file * fcheck_files(struct files_struct *files, unsigned int fd)
  11 {
  12         struct file * file = NULL;
  13
  14         if (fd < files->max_fds)
  15                 file = files->fd[fd];
  16         return file;
  17 }
  18
  19 /*
  20  * Check whether the specified fd has an open file.
  21  */
  22 static inline struct file * fcheck(unsigned int fd)
  23 {
  24         struct file * file = NULL;
  25         struct files_struct *files = current->files;
  26
  27         if (fd < files->max_fds)
  28                 file = files->fd[fd];
  29         return file;
  30 }
  31
  32 static inline struct file * frip(struct files_struct *files, unsigned int fd)
  33 {
  34         struct file * file = NULL;
  35
  36         if (fd < files->max_fds)
  37                 file = xchg(&files->fd[fd], NULL);
  38         return file;
  39 }
  40
  41 static inline struct file * fget(unsigned int fd)
  42 {
  43         struct file * file = NULL;
  44         struct files_struct *files = current->files;
  45
  46         read_lock(&files->file_lock);
  47         file = fcheck(fd);
  48         if (file)
  49                 get_file(file);
  50         read_unlock(&files->file_lock);
  51         return file;
  52 }
  53
  54 /*
  55  * 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
  56  *
  57  * Since those functions where calling other functions, it was completely
  58  * bogus to make them all "extern inline".
  59  *
  60  * The removal of this pseudo optimization saved me scandalous:
  61  *
  62  *              3756 (i386 arch)
  63  *
  64  * precious bytes from my kernel, even without counting all the code compiled
  65  * as module!
  66  *
  67  * I suspect there are many other similar "optimizations" across the
  68  * kernel...
  69  */
  70 static inline void fput(struct file * file)
  71 {
  72         if (atomic_dec_and_test(&file->f_count))
  73                 _fput(file);
  74 }
  75 extern void put_filp(struct file *);
  76
  77 extern int get_unused_fd(void);
  78
  79 static inline void __put_unused_fd(struct files_struct *files, unsigned int fd)
  80 {
  81         FD_CLR(fd, files->open_fds);
  82         if (fd < files->next_fd)
  83                 files->next_fd = fd;
  84 }
  85
  86 static inline void put_unused_fd(unsigned int fd)
  87 {
  88         struct files_struct *files = current->files;
  89
  90         write_lock(&files->file_lock);
  91         __put_unused_fd(files, fd);
  92         write_unlock(&files->file_lock);
  93 }
  94
  95 /*
  96  * Install a file pointer in the fd array.
  97  *
  98  * The VFS is full of places where we drop the files lock between
  99  * setting the open_fds bitmap and installing the file in the file
 100  * array.  At any such point, we are vulnerable to a dup2() race
 101  * installing a file in the array before us.  We need to detect this and
 102  * fput() the struct file we are about to overwrite in this case.
 103  */
 104
 105 static inline void fd_install(unsigned int fd, struct file * file)
 106 {
 107         struct files_struct *files = current->files;
 108         struct file * result;
 109
 110         write_lock(&files->file_lock);
 111         result = xchg(&files->fd[fd], file);
 112         write_unlock(&files->file_lock);
 113         if (result)
 114                 fput(result);
 115 }
 116
 117 void put_files_struct(struct files_struct *fs);
 118
 119 #endif /* __LINUX_FILE_H */