diff options
author | Dmitry Torokhov <dmitry.torokhov@gmail.com> | 2009-05-08 21:29:27 -0400 |
---|---|---|
committer | Dmitry Torokhov <dmitry.torokhov@gmail.com> | 2009-05-08 21:29:27 -0400 |
commit | d585a021c0b10b0477d6b608c53e1feb8cde0507 (patch) | |
tree | 5ca059da1db7f15d4b29427644ad9c08270c885c /include/linux/fs.h | |
parent | 84e5b0d00f8f84c4ae226be131d4bebbcee88bd3 (diff) | |
parent | 091bf7624d1c90cec9e578a18529f615213ff847 (diff) |
Merge commit 'v2.6.30-rc5' into next
Diffstat (limited to 'include/linux/fs.h')
-rw-r--r-- | include/linux/fs.h | 353 |
1 files changed, 273 insertions, 80 deletions
diff --git a/include/linux/fs.h b/include/linux/fs.h index 92734c0012e6..5bed436f4353 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h | |||
@@ -87,6 +87,60 @@ struct inodes_stat_t { | |||
87 | */ | 87 | */ |
88 | #define FMODE_NOCMTIME ((__force fmode_t)2048) | 88 | #define FMODE_NOCMTIME ((__force fmode_t)2048) |
89 | 89 | ||
90 | /* | ||
91 | * The below are the various read and write types that we support. Some of | ||
92 | * them include behavioral modifiers that send information down to the | ||
93 | * block layer and IO scheduler. Terminology: | ||
94 | * | ||
95 | * The block layer uses device plugging to defer IO a little bit, in | ||
96 | * the hope that we will see more IO very shortly. This increases | ||
97 | * coalescing of adjacent IO and thus reduces the number of IOs we | ||
98 | * have to send to the device. It also allows for better queuing, | ||
99 | * if the IO isn't mergeable. If the caller is going to be waiting | ||
100 | * for the IO, then he must ensure that the device is unplugged so | ||
101 | * that the IO is dispatched to the driver. | ||
102 | * | ||
103 | * All IO is handled async in Linux. This is fine for background | ||
104 | * writes, but for reads or writes that someone waits for completion | ||
105 | * on, we want to notify the block layer and IO scheduler so that they | ||
106 | * know about it. That allows them to make better scheduling | ||
107 | * decisions. So when the below references 'sync' and 'async', it | ||
108 | * is referencing this priority hint. | ||
109 | * | ||
110 | * With that in mind, the available types are: | ||
111 | * | ||
112 | * READ A normal read operation. Device will be plugged. | ||
113 | * READ_SYNC A synchronous read. Device is not plugged, caller can | ||
114 | * immediately wait on this read without caring about | ||
115 | * unplugging. | ||
116 | * READA Used for read-ahead operations. Lower priority, and the | ||
117 | * block layer could (in theory) choose to ignore this | ||
118 | * request if it runs into resource problems. | ||
119 | * WRITE A normal async write. Device will be plugged. | ||
120 | * SWRITE Like WRITE, but a special case for ll_rw_block() that | ||
121 | * tells it to lock the buffer first. Normally a buffer | ||
122 | * must be locked before doing IO. | ||
123 | * WRITE_SYNC_PLUG Synchronous write. Identical to WRITE, but passes down | ||
124 | * the hint that someone will be waiting on this IO | ||
125 | * shortly. The device must still be unplugged explicitly, | ||
126 | * WRITE_SYNC_PLUG does not do this as we could be | ||
127 | * submitting more writes before we actually wait on any | ||
128 | * of them. | ||
129 | * WRITE_SYNC Like WRITE_SYNC_PLUG, but also unplugs the device | ||
130 | * immediately after submission. The write equivalent | ||
131 | * of READ_SYNC. | ||
132 | * WRITE_ODIRECT Special case write for O_DIRECT only. | ||
133 | * SWRITE_SYNC | ||
134 | * SWRITE_SYNC_PLUG Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer. | ||
135 | * See SWRITE. | ||
136 | * WRITE_BARRIER Like WRITE, but tells the block layer that all | ||
137 | * previously submitted writes must be safely on storage | ||
138 | * before this one is started. Also guarantees that when | ||
139 | * this write is complete, it itself is also safely on | ||
140 | * storage. Prevents reordering of writes on both sides | ||
141 | * of this IO. | ||
142 | * | ||
143 | */ | ||
90 | #define RW_MASK 1 | 144 | #define RW_MASK 1 |
91 | #define RWA_MASK 2 | 145 | #define RWA_MASK 2 |
92 | #define READ 0 | 146 | #define READ 0 |
@@ -95,9 +149,18 @@ struct inodes_stat_t { | |||
95 | #define SWRITE 3 /* for ll_rw_block() - wait for buffer lock */ | 149 | #define SWRITE 3 /* for ll_rw_block() - wait for buffer lock */ |
96 | #define READ_SYNC (READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG)) | 150 | #define READ_SYNC (READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG)) |
97 | #define READ_META (READ | (1 << BIO_RW_META)) | 151 | #define READ_META (READ | (1 << BIO_RW_META)) |
98 | #define WRITE_SYNC (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG)) | 152 | #define WRITE_SYNC_PLUG (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE)) |
99 | #define SWRITE_SYNC (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG)) | 153 | #define WRITE_SYNC (WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG)) |
154 | #define WRITE_ODIRECT (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG)) | ||
155 | #define SWRITE_SYNC_PLUG \ | ||
156 | (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE)) | ||
157 | #define SWRITE_SYNC (SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG)) | ||
100 | #define WRITE_BARRIER (WRITE | (1 << BIO_RW_BARRIER)) | 158 | #define WRITE_BARRIER (WRITE | (1 << BIO_RW_BARRIER)) |
159 | |||
160 | /* | ||
161 | * These aren't really reads or writes, they pass down information about | ||
162 | * parts of device that are now unused by the file system. | ||
163 | */ | ||
101 | #define DISCARD_NOBARRIER (1 << BIO_RW_DISCARD) | 164 | #define DISCARD_NOBARRIER (1 << BIO_RW_DISCARD) |
102 | #define DISCARD_BARRIER ((1 << BIO_RW_DISCARD) | (1 << BIO_RW_BARRIER)) | 165 | #define DISCARD_BARRIER ((1 << BIO_RW_DISCARD) | (1 << BIO_RW_BARRIER)) |
103 | 166 | ||
@@ -141,6 +204,7 @@ struct inodes_stat_t { | |||
141 | #define MS_RELATIME (1<<21) /* Update atime relative to mtime/ctime. */ | 204 | #define MS_RELATIME (1<<21) /* Update atime relative to mtime/ctime. */ |
142 | #define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */ | 205 | #define MS_KERNMOUNT (1<<22) /* this is a kern_mount call */ |
143 | #define MS_I_VERSION (1<<23) /* Update inode I_version field */ | 206 | #define MS_I_VERSION (1<<23) /* Update inode I_version field */ |
207 | #define MS_STRICTATIME (1<<24) /* Always perform atime updates */ | ||
144 | #define MS_ACTIVE (1<<30) | 208 | #define MS_ACTIVE (1<<30) |
145 | #define MS_NOUSER (1<<31) | 209 | #define MS_NOUSER (1<<31) |
146 | 210 | ||
@@ -733,9 +797,6 @@ enum inode_i_mutex_lock_class | |||
733 | I_MUTEX_QUOTA | 797 | I_MUTEX_QUOTA |
734 | }; | 798 | }; |
735 | 799 | ||
736 | extern void inode_double_lock(struct inode *inode1, struct inode *inode2); | ||
737 | extern void inode_double_unlock(struct inode *inode1, struct inode *inode2); | ||
738 | |||
739 | /* | 800 | /* |
740 | * NOTE: in a 32bit arch with a preemptable kernel and | 801 | * NOTE: in a 32bit arch with a preemptable kernel and |
741 | * an UP compile the i_size_read/write must be atomic | 802 | * an UP compile the i_size_read/write must be atomic |
@@ -848,6 +909,7 @@ struct file { | |||
848 | #define f_dentry f_path.dentry | 909 | #define f_dentry f_path.dentry |
849 | #define f_vfsmnt f_path.mnt | 910 | #define f_vfsmnt f_path.mnt |
850 | const struct file_operations *f_op; | 911 | const struct file_operations *f_op; |
912 | spinlock_t f_lock; /* f_ep_links, f_flags, no IRQ */ | ||
851 | atomic_long_t f_count; | 913 | atomic_long_t f_count; |
852 | unsigned int f_flags; | 914 | unsigned int f_flags; |
853 | fmode_t f_mode; | 915 | fmode_t f_mode; |
@@ -866,7 +928,6 @@ struct file { | |||
866 | #ifdef CONFIG_EPOLL | 928 | #ifdef CONFIG_EPOLL |
867 | /* Used by fs/eventpoll.c to link all the hooks to this file */ | 929 | /* Used by fs/eventpoll.c to link all the hooks to this file */ |
868 | struct list_head f_ep_links; | 930 | struct list_head f_ep_links; |
869 | spinlock_t f_ep_lock; | ||
870 | #endif /* #ifdef CONFIG_EPOLL */ | 931 | #endif /* #ifdef CONFIG_EPOLL */ |
871 | struct address_space *f_mapping; | 932 | struct address_space *f_mapping; |
872 | #ifdef CONFIG_DEBUG_WRITECOUNT | 933 | #ifdef CONFIG_DEBUG_WRITECOUNT |
@@ -1063,34 +1124,147 @@ extern int lease_modify(struct file_lock **, int); | |||
1063 | extern int lock_may_read(struct inode *, loff_t start, unsigned long count); | 1124 | extern int lock_may_read(struct inode *, loff_t start, unsigned long count); |
1064 | extern int lock_may_write(struct inode *, loff_t start, unsigned long count); | 1125 | extern int lock_may_write(struct inode *, loff_t start, unsigned long count); |
1065 | #else /* !CONFIG_FILE_LOCKING */ | 1126 | #else /* !CONFIG_FILE_LOCKING */ |
1066 | #define fcntl_getlk(a, b) ({ -EINVAL; }) | 1127 | static inline int fcntl_getlk(struct file *file, struct flock __user *user) |
1067 | #define fcntl_setlk(a, b, c, d) ({ -EACCES; }) | 1128 | { |
1129 | return -EINVAL; | ||
1130 | } | ||
1131 | |||
1132 | static inline int fcntl_setlk(unsigned int fd, struct file *file, | ||
1133 | unsigned int cmd, struct flock __user *user) | ||
1134 | { | ||
1135 | return -EACCES; | ||
1136 | } | ||
1137 | |||
1068 | #if BITS_PER_LONG == 32 | 1138 | #if BITS_PER_LONG == 32 |
1069 | #define fcntl_getlk64(a, b) ({ -EINVAL; }) | 1139 | static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user) |
1070 | #define fcntl_setlk64(a, b, c, d) ({ -EACCES; }) | 1140 | { |
1141 | return -EINVAL; | ||
1142 | } | ||
1143 | |||
1144 | static inline int fcntl_setlk64(unsigned int fd, struct file *file, | ||
1145 | unsigned int cmd, struct flock64 __user *user) | ||
1146 | { | ||
1147 | return -EACCES; | ||
1148 | } | ||
1071 | #endif | 1149 | #endif |
1072 | #define fcntl_setlease(a, b, c) ({ 0; }) | 1150 | static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg) |
1073 | #define fcntl_getlease(a) ({ 0; }) | 1151 | { |
1074 | #define locks_init_lock(a) ({ }) | 1152 | return 0; |
1075 | #define __locks_copy_lock(a, b) ({ }) | 1153 | } |
1076 | #define locks_copy_lock(a, b) ({ }) | 1154 | |
1077 | #define locks_remove_posix(a, b) ({ }) | 1155 | static inline int fcntl_getlease(struct file *filp) |
1078 | #define locks_remove_flock(a) ({ }) | 1156 | { |
1079 | #define posix_test_lock(a, b) ({ 0; }) | 1157 | return 0; |
1080 | #define posix_lock_file(a, b, c) ({ -ENOLCK; }) | 1158 | } |
1081 | #define posix_lock_file_wait(a, b) ({ -ENOLCK; }) | 1159 | |
1082 | #define posix_unblock_lock(a, b) (-ENOENT) | 1160 | static inline void locks_init_lock(struct file_lock *fl) |
1083 | #define vfs_test_lock(a, b) ({ 0; }) | 1161 | { |
1084 | #define vfs_lock_file(a, b, c, d) (-ENOLCK) | 1162 | return; |
1085 | #define vfs_cancel_lock(a, b) ({ 0; }) | 1163 | } |
1086 | #define flock_lock_file_wait(a, b) ({ -ENOLCK; }) | 1164 | |
1087 | #define __break_lease(a, b) ({ 0; }) | 1165 | static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl) |
1088 | #define lease_get_mtime(a, b) ({ }) | 1166 | { |
1089 | #define generic_setlease(a, b, c) ({ -EINVAL; }) | 1167 | return; |
1090 | #define vfs_setlease(a, b, c) ({ -EINVAL; }) | 1168 | } |
1091 | #define lease_modify(a, b) ({ -EINVAL; }) | 1169 | |
1092 | #define lock_may_read(a, b, c) ({ 1; }) | 1170 | static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl) |
1093 | #define lock_may_write(a, b, c) ({ 1; }) | 1171 | { |
1172 | return; | ||
1173 | } | ||
1174 | |||
1175 | static inline void locks_remove_posix(struct file *filp, fl_owner_t owner) | ||
1176 | { | ||
1177 | return; | ||
1178 | } | ||
1179 | |||
1180 | static inline void locks_remove_flock(struct file *filp) | ||
1181 | { | ||
1182 | return; | ||
1183 | } | ||
1184 | |||
1185 | static inline void posix_test_lock(struct file *filp, struct file_lock *fl) | ||
1186 | { | ||
1187 | return; | ||
1188 | } | ||
1189 | |||
1190 | static inline int posix_lock_file(struct file *filp, struct file_lock *fl, | ||
1191 | struct file_lock *conflock) | ||
1192 | { | ||
1193 | return -ENOLCK; | ||
1194 | } | ||
1195 | |||
1196 | static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl) | ||
1197 | { | ||
1198 | return -ENOLCK; | ||
1199 | } | ||
1200 | |||
1201 | static inline int posix_unblock_lock(struct file *filp, | ||
1202 | struct file_lock *waiter) | ||
1203 | { | ||
1204 | return -ENOENT; | ||
1205 | } | ||
1206 | |||
1207 | static inline int vfs_test_lock(struct file *filp, struct file_lock *fl) | ||
1208 | { | ||
1209 | return 0; | ||
1210 | } | ||
1211 | |||
1212 | static inline int vfs_lock_file(struct file *filp, unsigned int cmd, | ||
1213 | struct file_lock *fl, struct file_lock *conf) | ||
1214 | { | ||
1215 | return -ENOLCK; | ||
1216 | } | ||
1217 | |||
1218 | static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl) | ||
1219 | { | ||
1220 | return 0; | ||
1221 | } | ||
1222 | |||
1223 | static inline int flock_lock_file_wait(struct file *filp, | ||
1224 | struct file_lock *request) | ||
1225 | { | ||
1226 | return -ENOLCK; | ||
1227 | } | ||
1228 | |||
1229 | static inline int __break_lease(struct inode *inode, unsigned int mode) | ||
1230 | { | ||
1231 | return 0; | ||
1232 | } | ||
1233 | |||
1234 | static inline void lease_get_mtime(struct inode *inode, struct timespec *time) | ||
1235 | { | ||
1236 | return; | ||
1237 | } | ||
1238 | |||
1239 | static inline int generic_setlease(struct file *filp, long arg, | ||
1240 | struct file_lock **flp) | ||
1241 | { | ||
1242 | return -EINVAL; | ||
1243 | } | ||
1244 | |||
1245 | static inline int vfs_setlease(struct file *filp, long arg, | ||
1246 | struct file_lock **lease) | ||
1247 | { | ||
1248 | return -EINVAL; | ||
1249 | } | ||
1250 | |||
1251 | static inline int lease_modify(struct file_lock **before, int arg) | ||
1252 | { | ||
1253 | return -EINVAL; | ||
1254 | } | ||
1255 | |||
1256 | static inline int lock_may_read(struct inode *inode, loff_t start, | ||
1257 | unsigned long len) | ||
1258 | { | ||
1259 | return 1; | ||
1260 | } | ||
1261 | |||
1262 | static inline int lock_may_write(struct inode *inode, loff_t start, | ||
1263 | unsigned long len) | ||
1264 | { | ||
1265 | return 1; | ||
1266 | } | ||
1267 | |||
1094 | #endif /* !CONFIG_FILE_LOCKING */ | 1268 | #endif /* !CONFIG_FILE_LOCKING */ |
1095 | 1269 | ||
1096 | 1270 | ||
@@ -1581,6 +1755,9 @@ struct file_system_type { | |||
1581 | struct lock_class_key i_alloc_sem_key; | 1755 | struct lock_class_key i_alloc_sem_key; |
1582 | }; | 1756 | }; |
1583 | 1757 | ||
1758 | extern int get_sb_ns(struct file_system_type *fs_type, int flags, void *data, | ||
1759 | int (*fill_super)(struct super_block *, void *, int), | ||
1760 | struct vfsmount *mnt); | ||
1584 | extern int get_sb_bdev(struct file_system_type *fs_type, | 1761 | extern int get_sb_bdev(struct file_system_type *fs_type, |
1585 | int flags, const char *dev_name, void *data, | 1762 | int flags, const char *dev_name, void *data, |
1586 | int (*fill_super)(struct super_block *, void *, int), | 1763 | int (*fill_super)(struct super_block *, void *, int), |
@@ -1606,7 +1783,7 @@ struct super_block *sget(struct file_system_type *type, | |||
1606 | extern int get_sb_pseudo(struct file_system_type *, char *, | 1783 | extern int get_sb_pseudo(struct file_system_type *, char *, |
1607 | const struct super_operations *ops, unsigned long, | 1784 | const struct super_operations *ops, unsigned long, |
1608 | struct vfsmount *mnt); | 1785 | struct vfsmount *mnt); |
1609 | extern int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb); | 1786 | extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb); |
1610 | int __put_super_and_need_restart(struct super_block *sb); | 1787 | int __put_super_and_need_restart(struct super_block *sb); |
1611 | 1788 | ||
1612 | /* Alas, no aliases. Too much hassle with bringing module.h everywhere */ | 1789 | /* Alas, no aliases. Too much hassle with bringing module.h everywhere */ |
@@ -1627,6 +1804,8 @@ extern void drop_collected_mounts(struct vfsmount *); | |||
1627 | 1804 | ||
1628 | extern int vfs_statfs(struct dentry *, struct kstatfs *); | 1805 | extern int vfs_statfs(struct dentry *, struct kstatfs *); |
1629 | 1806 | ||
1807 | extern int current_umask(void); | ||
1808 | |||
1630 | /* /sys/fs */ | 1809 | /* /sys/fs */ |
1631 | extern struct kobject *fs_kobj; | 1810 | extern struct kobject *fs_kobj; |
1632 | 1811 | ||
@@ -1687,13 +1866,44 @@ static inline int break_lease(struct inode *inode, unsigned int mode) | |||
1687 | return 0; | 1866 | return 0; |
1688 | } | 1867 | } |
1689 | #else /* !CONFIG_FILE_LOCKING */ | 1868 | #else /* !CONFIG_FILE_LOCKING */ |
1690 | #define locks_mandatory_locked(a) ({ 0; }) | 1869 | static inline int locks_mandatory_locked(struct inode *inode) |
1691 | #define locks_mandatory_area(a, b, c, d, e) ({ 0; }) | 1870 | { |
1692 | #define __mandatory_lock(a) ({ 0; }) | 1871 | return 0; |
1693 | #define mandatory_lock(a) ({ 0; }) | 1872 | } |
1694 | #define locks_verify_locked(a) ({ 0; }) | 1873 | |
1695 | #define locks_verify_truncate(a, b, c) ({ 0; }) | 1874 | static inline int locks_mandatory_area(int rw, struct inode *inode, |
1696 | #define break_lease(a, b) ({ 0; }) | 1875 | struct file *filp, loff_t offset, |
1876 | size_t count) | ||
1877 | { | ||
1878 | return 0; | ||
1879 | } | ||
1880 | |||
1881 | static inline int __mandatory_lock(struct inode *inode) | ||
1882 | { | ||
1883 | return 0; | ||
1884 | } | ||
1885 | |||
1886 | static inline int mandatory_lock(struct inode *inode) | ||
1887 | { | ||
1888 | return 0; | ||
1889 | } | ||
1890 | |||
1891 | static inline int locks_verify_locked(struct inode *inode) | ||
1892 | { | ||
1893 | return 0; | ||
1894 | } | ||
1895 | |||
1896 | static inline int locks_verify_truncate(struct inode *inode, struct file *filp, | ||
1897 | size_t size) | ||
1898 | { | ||
1899 | return 0; | ||
1900 | } | ||
1901 | |||
1902 | static inline int break_lease(struct inode *inode, unsigned int mode) | ||
1903 | { | ||
1904 | return 0; | ||
1905 | } | ||
1906 | |||
1697 | #endif /* CONFIG_FILE_LOCKING */ | 1907 | #endif /* CONFIG_FILE_LOCKING */ |
1698 | 1908 | ||
1699 | /* fs/open.c */ | 1909 | /* fs/open.c */ |
@@ -1730,8 +1940,28 @@ extern void bd_set_size(struct block_device *, loff_t size); | |||
1730 | extern void bd_forget(struct inode *inode); | 1940 | extern void bd_forget(struct inode *inode); |
1731 | extern void bdput(struct block_device *); | 1941 | extern void bdput(struct block_device *); |
1732 | extern struct block_device *open_by_devnum(dev_t, fmode_t); | 1942 | extern struct block_device *open_by_devnum(dev_t, fmode_t); |
1943 | extern void invalidate_bdev(struct block_device *); | ||
1944 | extern int sync_blockdev(struct block_device *bdev); | ||
1945 | extern struct super_block *freeze_bdev(struct block_device *); | ||
1946 | extern void emergency_thaw_all(void); | ||
1947 | extern int thaw_bdev(struct block_device *bdev, struct super_block *sb); | ||
1948 | extern int fsync_bdev(struct block_device *); | ||
1949 | extern int fsync_super(struct super_block *); | ||
1950 | extern int fsync_no_super(struct block_device *); | ||
1733 | #else | 1951 | #else |
1734 | static inline void bd_forget(struct inode *inode) {} | 1952 | static inline void bd_forget(struct inode *inode) {} |
1953 | static inline int sync_blockdev(struct block_device *bdev) { return 0; } | ||
1954 | static inline void invalidate_bdev(struct block_device *bdev) {} | ||
1955 | |||
1956 | static inline struct super_block *freeze_bdev(struct block_device *sb) | ||
1957 | { | ||
1958 | return NULL; | ||
1959 | } | ||
1960 | |||
1961 | static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb) | ||
1962 | { | ||
1963 | return 0; | ||
1964 | } | ||
1735 | #endif | 1965 | #endif |
1736 | extern const struct file_operations def_blk_fops; | 1966 | extern const struct file_operations def_blk_fops; |
1737 | extern const struct file_operations def_chr_fops; | 1967 | extern const struct file_operations def_chr_fops; |
@@ -1881,7 +2111,6 @@ static inline void allow_write_access(struct file *file) | |||
1881 | if (file) | 2111 | if (file) |
1882 | atomic_inc(&file->f_path.dentry->d_inode->i_writecount); | 2112 | atomic_inc(&file->f_path.dentry->d_inode->i_writecount); |
1883 | } | 2113 | } |
1884 | extern int do_pipe(int *); | ||
1885 | extern int do_pipe_flags(int *, int); | 2114 | extern int do_pipe_flags(int *, int); |
1886 | extern struct file *create_read_pipe(struct file *f, int flags); | 2115 | extern struct file *create_read_pipe(struct file *f, int flags); |
1887 | extern struct file *create_write_pipe(int flags); | 2116 | extern struct file *create_write_pipe(int flags); |
@@ -1977,8 +2206,6 @@ extern ssize_t generic_file_splice_read(struct file *, loff_t *, | |||
1977 | struct pipe_inode_info *, size_t, unsigned int); | 2206 | struct pipe_inode_info *, size_t, unsigned int); |
1978 | extern ssize_t generic_file_splice_write(struct pipe_inode_info *, | 2207 | extern ssize_t generic_file_splice_write(struct pipe_inode_info *, |
1979 | struct file *, loff_t *, size_t, unsigned int); | 2208 | struct file *, loff_t *, size_t, unsigned int); |
1980 | extern ssize_t generic_file_splice_write_nolock(struct pipe_inode_info *, | ||
1981 | struct file *, loff_t *, size_t, unsigned int); | ||
1982 | extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe, | 2209 | extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe, |
1983 | struct file *out, loff_t *, size_t len, unsigned int flags); | 2210 | struct file *out, loff_t *, size_t len, unsigned int flags); |
1984 | extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out, | 2211 | extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out, |
@@ -2072,9 +2299,8 @@ extern int vfs_readdir(struct file *, filldir_t, void *); | |||
2072 | 2299 | ||
2073 | extern int vfs_stat(char __user *, struct kstat *); | 2300 | extern int vfs_stat(char __user *, struct kstat *); |
2074 | extern int vfs_lstat(char __user *, struct kstat *); | 2301 | extern int vfs_lstat(char __user *, struct kstat *); |
2075 | extern int vfs_stat_fd(int dfd, char __user *, struct kstat *); | ||
2076 | extern int vfs_lstat_fd(int dfd, char __user *, struct kstat *); | ||
2077 | extern int vfs_fstat(unsigned int, struct kstat *); | 2302 | extern int vfs_fstat(unsigned int, struct kstat *); |
2303 | extern int vfs_fstatat(int , char __user *, struct kstat *, int); | ||
2078 | 2304 | ||
2079 | extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, | 2305 | extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd, |
2080 | unsigned long arg); | 2306 | unsigned long arg); |
@@ -2171,19 +2397,7 @@ ssize_t simple_transaction_read(struct file *file, char __user *buf, | |||
2171 | size_t size, loff_t *pos); | 2397 | size_t size, loff_t *pos); |
2172 | int simple_transaction_release(struct inode *inode, struct file *file); | 2398 | int simple_transaction_release(struct inode *inode, struct file *file); |
2173 | 2399 | ||
2174 | static inline void simple_transaction_set(struct file *file, size_t n) | 2400 | void simple_transaction_set(struct file *file, size_t n); |
2175 | { | ||
2176 | struct simple_transaction_argresp *ar = file->private_data; | ||
2177 | |||
2178 | BUG_ON(n > SIMPLE_TRANSACTION_LIMIT); | ||
2179 | |||
2180 | /* | ||
2181 | * The barrier ensures that ar->size will really remain zero until | ||
2182 | * ar->data is ready for reading. | ||
2183 | */ | ||
2184 | smp_mb(); | ||
2185 | ar->size = n; | ||
2186 | } | ||
2187 | 2401 | ||
2188 | /* | 2402 | /* |
2189 | * simple attribute files | 2403 | * simple attribute files |
@@ -2230,32 +2444,11 @@ ssize_t simple_attr_read(struct file *file, char __user *buf, | |||
2230 | ssize_t simple_attr_write(struct file *file, const char __user *buf, | 2444 | ssize_t simple_attr_write(struct file *file, const char __user *buf, |
2231 | size_t len, loff_t *ppos); | 2445 | size_t len, loff_t *ppos); |
2232 | 2446 | ||
2233 | |||
2234 | #ifdef CONFIG_SECURITY | ||
2235 | static inline char *alloc_secdata(void) | ||
2236 | { | ||
2237 | return (char *)get_zeroed_page(GFP_KERNEL); | ||
2238 | } | ||
2239 | |||
2240 | static inline void free_secdata(void *secdata) | ||
2241 | { | ||
2242 | free_page((unsigned long)secdata); | ||
2243 | } | ||
2244 | #else | ||
2245 | static inline char *alloc_secdata(void) | ||
2246 | { | ||
2247 | return (char *)1; | ||
2248 | } | ||
2249 | |||
2250 | static inline void free_secdata(void *secdata) | ||
2251 | { } | ||
2252 | #endif /* CONFIG_SECURITY */ | ||
2253 | |||
2254 | struct ctl_table; | 2447 | struct ctl_table; |
2255 | int proc_nr_files(struct ctl_table *table, int write, struct file *filp, | 2448 | int proc_nr_files(struct ctl_table *table, int write, struct file *filp, |
2256 | void __user *buffer, size_t *lenp, loff_t *ppos); | 2449 | void __user *buffer, size_t *lenp, loff_t *ppos); |
2257 | 2450 | ||
2258 | int get_filesystem_list(char * buf); | 2451 | int __init get_filesystem_list(char *buf); |
2259 | 2452 | ||
2260 | #endif /* __KERNEL__ */ | 2453 | #endif /* __KERNEL__ */ |
2261 | #endif /* _LINUX_FS_H */ | 2454 | #endif /* _LINUX_FS_H */ |