[CVE-2009-0029] System call wrappers part 11
[linux-2.6.git] / fs / stat.c
1 /*
2  *  linux/fs/stat.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 #include <linux/module.h>
8 #include <linux/mm.h>
9 #include <linux/errno.h>
10 #include <linux/file.h>
11 #include <linux/highuid.h>
12 #include <linux/fs.h>
13 #include <linux/namei.h>
14 #include <linux/security.h>
15 #include <linux/syscalls.h>
16 #include <linux/pagemap.h>
17
18 #include <asm/uaccess.h>
19 #include <asm/unistd.h>
20
21 void generic_fillattr(struct inode *inode, struct kstat *stat)
22 {
23         stat->dev = inode->i_sb->s_dev;
24         stat->ino = inode->i_ino;
25         stat->mode = inode->i_mode;
26         stat->nlink = inode->i_nlink;
27         stat->uid = inode->i_uid;
28         stat->gid = inode->i_gid;
29         stat->rdev = inode->i_rdev;
30         stat->atime = inode->i_atime;
31         stat->mtime = inode->i_mtime;
32         stat->ctime = inode->i_ctime;
33         stat->size = i_size_read(inode);
34         stat->blocks = inode->i_blocks;
35         stat->blksize = (1 << inode->i_blkbits);
36 }
37
38 EXPORT_SYMBOL(generic_fillattr);
39
40 int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
41 {
42         struct inode *inode = dentry->d_inode;
43         int retval;
44
45         retval = security_inode_getattr(mnt, dentry);
46         if (retval)
47                 return retval;
48
49         if (inode->i_op->getattr)
50                 return inode->i_op->getattr(mnt, dentry, stat);
51
52         generic_fillattr(inode, stat);
53         return 0;
54 }
55
56 EXPORT_SYMBOL(vfs_getattr);
57
58 int vfs_stat_fd(int dfd, char __user *name, struct kstat *stat)
59 {
60         struct path path;
61         int error;
62
63         error = user_path_at(dfd, name, LOOKUP_FOLLOW, &path);
64         if (!error) {
65                 error = vfs_getattr(path.mnt, path.dentry, stat);
66                 path_put(&path);
67         }
68         return error;
69 }
70
71 int vfs_stat(char __user *name, struct kstat *stat)
72 {
73         return vfs_stat_fd(AT_FDCWD, name, stat);
74 }
75
76 EXPORT_SYMBOL(vfs_stat);
77
78 int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat)
79 {
80         struct path path;
81         int error;
82
83         error = user_path_at(dfd, name, 0, &path);
84         if (!error) {
85                 error = vfs_getattr(path.mnt, path.dentry, stat);
86                 path_put(&path);
87         }
88         return error;
89 }
90
91 int vfs_lstat(char __user *name, struct kstat *stat)
92 {
93         return vfs_lstat_fd(AT_FDCWD, name, stat);
94 }
95
96 EXPORT_SYMBOL(vfs_lstat);
97
98 int vfs_fstat(unsigned int fd, struct kstat *stat)
99 {
100         struct file *f = fget(fd);
101         int error = -EBADF;
102
103         if (f) {
104                 error = vfs_getattr(f->f_path.mnt, f->f_path.dentry, stat);
105                 fput(f);
106         }
107         return error;
108 }
109
110 EXPORT_SYMBOL(vfs_fstat);
111
112 #ifdef __ARCH_WANT_OLD_STAT
113
114 /*
115  * For backward compatibility?  Maybe this should be moved
116  * into arch/i386 instead?
117  */
118 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
119 {
120         static int warncount = 5;
121         struct __old_kernel_stat tmp;
122         
123         if (warncount > 0) {
124                 warncount--;
125                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
126                         current->comm);
127         } else if (warncount < 0) {
128                 /* it's laughable, but... */
129                 warncount = 0;
130         }
131
132         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
133         tmp.st_dev = old_encode_dev(stat->dev);
134         tmp.st_ino = stat->ino;
135         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
136                 return -EOVERFLOW;
137         tmp.st_mode = stat->mode;
138         tmp.st_nlink = stat->nlink;
139         if (tmp.st_nlink != stat->nlink)
140                 return -EOVERFLOW;
141         SET_UID(tmp.st_uid, stat->uid);
142         SET_GID(tmp.st_gid, stat->gid);
143         tmp.st_rdev = old_encode_dev(stat->rdev);
144 #if BITS_PER_LONG == 32
145         if (stat->size > MAX_NON_LFS)
146                 return -EOVERFLOW;
147 #endif  
148         tmp.st_size = stat->size;
149         tmp.st_atime = stat->atime.tv_sec;
150         tmp.st_mtime = stat->mtime.tv_sec;
151         tmp.st_ctime = stat->ctime.tv_sec;
152         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
153 }
154
155 SYSCALL_DEFINE2(stat, char __user *, filename, struct __old_kernel_stat __user *, statbuf)
156 {
157         struct kstat stat;
158         int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
159
160         if (!error)
161                 error = cp_old_stat(&stat, statbuf);
162
163         return error;
164 }
165
166 SYSCALL_DEFINE2(lstat, char __user *, filename, struct __old_kernel_stat __user *, statbuf)
167 {
168         struct kstat stat;
169         int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
170
171         if (!error)
172                 error = cp_old_stat(&stat, statbuf);
173
174         return error;
175 }
176
177 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
178 {
179         struct kstat stat;
180         int error = vfs_fstat(fd, &stat);
181
182         if (!error)
183                 error = cp_old_stat(&stat, statbuf);
184
185         return error;
186 }
187
188 #endif /* __ARCH_WANT_OLD_STAT */
189
190 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
191 {
192         struct stat tmp;
193
194 #if BITS_PER_LONG == 32
195         if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
196                 return -EOVERFLOW;
197 #else
198         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
199                 return -EOVERFLOW;
200 #endif
201
202         memset(&tmp, 0, sizeof(tmp));
203 #if BITS_PER_LONG == 32
204         tmp.st_dev = old_encode_dev(stat->dev);
205 #else
206         tmp.st_dev = new_encode_dev(stat->dev);
207 #endif
208         tmp.st_ino = stat->ino;
209         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
210                 return -EOVERFLOW;
211         tmp.st_mode = stat->mode;
212         tmp.st_nlink = stat->nlink;
213         if (tmp.st_nlink != stat->nlink)
214                 return -EOVERFLOW;
215         SET_UID(tmp.st_uid, stat->uid);
216         SET_GID(tmp.st_gid, stat->gid);
217 #if BITS_PER_LONG == 32
218         tmp.st_rdev = old_encode_dev(stat->rdev);
219 #else
220         tmp.st_rdev = new_encode_dev(stat->rdev);
221 #endif
222 #if BITS_PER_LONG == 32
223         if (stat->size > MAX_NON_LFS)
224                 return -EOVERFLOW;
225 #endif  
226         tmp.st_size = stat->size;
227         tmp.st_atime = stat->atime.tv_sec;
228         tmp.st_mtime = stat->mtime.tv_sec;
229         tmp.st_ctime = stat->ctime.tv_sec;
230 #ifdef STAT_HAVE_NSEC
231         tmp.st_atime_nsec = stat->atime.tv_nsec;
232         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
233         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
234 #endif
235         tmp.st_blocks = stat->blocks;
236         tmp.st_blksize = stat->blksize;
237         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
238 }
239
240 SYSCALL_DEFINE2(newstat, char __user *, filename, struct stat __user *, statbuf)
241 {
242         struct kstat stat;
243         int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
244
245         if (!error)
246                 error = cp_new_stat(&stat, statbuf);
247
248         return error;
249 }
250
251 SYSCALL_DEFINE2(newlstat, char __user *, filename, struct stat __user *, statbuf)
252 {
253         struct kstat stat;
254         int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
255
256         if (!error)
257                 error = cp_new_stat(&stat, statbuf);
258
259         return error;
260 }
261
262 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
263 asmlinkage long sys_newfstatat(int dfd, char __user *filename,
264                                 struct stat __user *statbuf, int flag)
265 {
266         struct kstat stat;
267         int error = -EINVAL;
268
269         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
270                 goto out;
271
272         if (flag & AT_SYMLINK_NOFOLLOW)
273                 error = vfs_lstat_fd(dfd, filename, &stat);
274         else
275                 error = vfs_stat_fd(dfd, filename, &stat);
276
277         if (!error)
278                 error = cp_new_stat(&stat, statbuf);
279
280 out:
281         return error;
282 }
283 #endif
284
285 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
286 {
287         struct kstat stat;
288         int error = vfs_fstat(fd, &stat);
289
290         if (!error)
291                 error = cp_new_stat(&stat, statbuf);
292
293         return error;
294 }
295
296 asmlinkage long sys_readlinkat(int dfd, const char __user *pathname,
297                                 char __user *buf, int bufsiz)
298 {
299         struct path path;
300         int error;
301
302         if (bufsiz <= 0)
303                 return -EINVAL;
304
305         error = user_path_at(dfd, pathname, 0, &path);
306         if (!error) {
307                 struct inode *inode = path.dentry->d_inode;
308
309                 error = -EINVAL;
310                 if (inode->i_op->readlink) {
311                         error = security_inode_readlink(path.dentry);
312                         if (!error) {
313                                 touch_atime(path.mnt, path.dentry);
314                                 error = inode->i_op->readlink(path.dentry,
315                                                               buf, bufsiz);
316                         }
317                 }
318                 path_put(&path);
319         }
320         return error;
321 }
322
323 asmlinkage long sys_readlink(const char __user *path, char __user *buf,
324                                 int bufsiz)
325 {
326         return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
327 }
328
329
330 /* ---------- LFS-64 ----------- */
331 #ifdef __ARCH_WANT_STAT64
332
333 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
334 {
335         struct stat64 tmp;
336
337         memset(&tmp, 0, sizeof(struct stat64));
338 #ifdef CONFIG_MIPS
339         /* mips has weird padding, so we don't get 64 bits there */
340         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
341                 return -EOVERFLOW;
342         tmp.st_dev = new_encode_dev(stat->dev);
343         tmp.st_rdev = new_encode_dev(stat->rdev);
344 #else
345         tmp.st_dev = huge_encode_dev(stat->dev);
346         tmp.st_rdev = huge_encode_dev(stat->rdev);
347 #endif
348         tmp.st_ino = stat->ino;
349         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
350                 return -EOVERFLOW;
351 #ifdef STAT64_HAS_BROKEN_ST_INO
352         tmp.__st_ino = stat->ino;
353 #endif
354         tmp.st_mode = stat->mode;
355         tmp.st_nlink = stat->nlink;
356         tmp.st_uid = stat->uid;
357         tmp.st_gid = stat->gid;
358         tmp.st_atime = stat->atime.tv_sec;
359         tmp.st_atime_nsec = stat->atime.tv_nsec;
360         tmp.st_mtime = stat->mtime.tv_sec;
361         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
362         tmp.st_ctime = stat->ctime.tv_sec;
363         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
364         tmp.st_size = stat->size;
365         tmp.st_blocks = stat->blocks;
366         tmp.st_blksize = stat->blksize;
367         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
368 }
369
370 SYSCALL_DEFINE2(stat64, char __user *, filename, struct stat64 __user *, statbuf)
371 {
372         struct kstat stat;
373         int error = vfs_stat(filename, &stat);
374
375         if (!error)
376                 error = cp_new_stat64(&stat, statbuf);
377
378         return error;
379 }
380
381 SYSCALL_DEFINE2(lstat64, char __user *, filename, struct stat64 __user *, statbuf)
382 {
383         struct kstat stat;
384         int error = vfs_lstat(filename, &stat);
385
386         if (!error)
387                 error = cp_new_stat64(&stat, statbuf);
388
389         return error;
390 }
391
392 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
393 {
394         struct kstat stat;
395         int error = vfs_fstat(fd, &stat);
396
397         if (!error)
398                 error = cp_new_stat64(&stat, statbuf);
399
400         return error;
401 }
402
403 asmlinkage long sys_fstatat64(int dfd, char __user *filename,
404                                struct stat64 __user *statbuf, int flag)
405 {
406         struct kstat stat;
407         int error = -EINVAL;
408
409         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
410                 goto out;
411
412         if (flag & AT_SYMLINK_NOFOLLOW)
413                 error = vfs_lstat_fd(dfd, filename, &stat);
414         else
415                 error = vfs_stat_fd(dfd, filename, &stat);
416
417         if (!error)
418                 error = cp_new_stat64(&stat, statbuf);
419
420 out:
421         return error;
422 }
423 #endif /* __ARCH_WANT_STAT64 */
424
425 void inode_add_bytes(struct inode *inode, loff_t bytes)
426 {
427         spin_lock(&inode->i_lock);
428         inode->i_blocks += bytes >> 9;
429         bytes &= 511;
430         inode->i_bytes += bytes;
431         if (inode->i_bytes >= 512) {
432                 inode->i_blocks++;
433                 inode->i_bytes -= 512;
434         }
435         spin_unlock(&inode->i_lock);
436 }
437
438 EXPORT_SYMBOL(inode_add_bytes);
439
440 void inode_sub_bytes(struct inode *inode, loff_t bytes)
441 {
442         spin_lock(&inode->i_lock);
443         inode->i_blocks -= bytes >> 9;
444         bytes &= 511;
445         if (inode->i_bytes < bytes) {
446                 inode->i_blocks--;
447                 inode->i_bytes += 512;
448         }
449         inode->i_bytes -= bytes;
450         spin_unlock(&inode->i_lock);
451 }
452
453 EXPORT_SYMBOL(inode_sub_bytes);
454
455 loff_t inode_get_bytes(struct inode *inode)
456 {
457         loff_t ret;
458
459         spin_lock(&inode->i_lock);
460         ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
461         spin_unlock(&inode->i_lock);
462         return ret;
463 }
464
465 EXPORT_SYMBOL(inode_get_bytes);
466
467 void inode_set_bytes(struct inode *inode, loff_t bytes)
468 {
469         /* Caller is here responsible for sufficient locking
470          * (ie. inode->i_lock) */
471         inode->i_blocks = bytes >> 9;
472         inode->i_bytes = bytes & 511;
473 }
474
475 EXPORT_SYMBOL(inode_set_bytes);