Remove obsolete #include <linux/config.h>
[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/smp_lock.h>
12 #include <linux/highuid.h>
13 #include <linux/fs.h>
14 #include <linux/namei.h>
15 #include <linux/security.h>
16 #include <linux/syscalls.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 = inode->i_blksize;
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         if (!stat->blksize) {
54                 struct super_block *s = inode->i_sb;
55                 unsigned blocks;
56                 blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
57                 stat->blocks = (s->s_blocksize / 512) * blocks;
58                 stat->blksize = s->s_blocksize;
59         }
60         return 0;
61 }
62
63 EXPORT_SYMBOL(vfs_getattr);
64
65 int vfs_stat_fd(int dfd, char __user *name, struct kstat *stat)
66 {
67         struct nameidata nd;
68         int error;
69
70         error = __user_walk_fd(dfd, name, LOOKUP_FOLLOW, &nd);
71         if (!error) {
72                 error = vfs_getattr(nd.mnt, nd.dentry, stat);
73                 path_release(&nd);
74         }
75         return error;
76 }
77
78 int vfs_stat(char __user *name, struct kstat *stat)
79 {
80         return vfs_stat_fd(AT_FDCWD, name, stat);
81 }
82
83 EXPORT_SYMBOL(vfs_stat);
84
85 int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat)
86 {
87         struct nameidata nd;
88         int error;
89
90         error = __user_walk_fd(dfd, name, 0, &nd);
91         if (!error) {
92                 error = vfs_getattr(nd.mnt, nd.dentry, stat);
93                 path_release(&nd);
94         }
95         return error;
96 }
97
98 int vfs_lstat(char __user *name, struct kstat *stat)
99 {
100         return vfs_lstat_fd(AT_FDCWD, name, stat);
101 }
102
103 EXPORT_SYMBOL(vfs_lstat);
104
105 int vfs_fstat(unsigned int fd, struct kstat *stat)
106 {
107         struct file *f = fget(fd);
108         int error = -EBADF;
109
110         if (f) {
111                 error = vfs_getattr(f->f_vfsmnt, f->f_dentry, stat);
112                 fput(f);
113         }
114         return error;
115 }
116
117 EXPORT_SYMBOL(vfs_fstat);
118
119 #ifdef __ARCH_WANT_OLD_STAT
120
121 /*
122  * For backward compatibility?  Maybe this should be moved
123  * into arch/i386 instead?
124  */
125 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
126 {
127         static int warncount = 5;
128         struct __old_kernel_stat tmp;
129         
130         if (warncount > 0) {
131                 warncount--;
132                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
133                         current->comm);
134         } else if (warncount < 0) {
135                 /* it's laughable, but... */
136                 warncount = 0;
137         }
138
139         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
140         tmp.st_dev = old_encode_dev(stat->dev);
141         tmp.st_ino = stat->ino;
142         tmp.st_mode = stat->mode;
143         tmp.st_nlink = stat->nlink;
144         if (tmp.st_nlink != stat->nlink)
145                 return -EOVERFLOW;
146         SET_UID(tmp.st_uid, stat->uid);
147         SET_GID(tmp.st_gid, stat->gid);
148         tmp.st_rdev = old_encode_dev(stat->rdev);
149 #if BITS_PER_LONG == 32
150         if (stat->size > MAX_NON_LFS)
151                 return -EOVERFLOW;
152 #endif  
153         tmp.st_size = stat->size;
154         tmp.st_atime = stat->atime.tv_sec;
155         tmp.st_mtime = stat->mtime.tv_sec;
156         tmp.st_ctime = stat->ctime.tv_sec;
157         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
158 }
159
160 asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
161 {
162         struct kstat stat;
163         int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
164
165         if (!error)
166                 error = cp_old_stat(&stat, statbuf);
167
168         return error;
169 }
170 asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
171 {
172         struct kstat stat;
173         int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
174
175         if (!error)
176                 error = cp_old_stat(&stat, statbuf);
177
178         return error;
179 }
180 asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user * statbuf)
181 {
182         struct kstat stat;
183         int error = vfs_fstat(fd, &stat);
184
185         if (!error)
186                 error = cp_old_stat(&stat, statbuf);
187
188         return error;
189 }
190
191 #endif /* __ARCH_WANT_OLD_STAT */
192
193 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
194 {
195         struct stat tmp;
196
197 #if BITS_PER_LONG == 32
198         if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
199                 return -EOVERFLOW;
200 #else
201         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
202                 return -EOVERFLOW;
203 #endif
204
205         memset(&tmp, 0, sizeof(tmp));
206 #if BITS_PER_LONG == 32
207         tmp.st_dev = old_encode_dev(stat->dev);
208 #else
209         tmp.st_dev = new_encode_dev(stat->dev);
210 #endif
211         tmp.st_ino = stat->ino;
212         tmp.st_mode = stat->mode;
213         tmp.st_nlink = stat->nlink;
214         if (tmp.st_nlink != stat->nlink)
215                 return -EOVERFLOW;
216         SET_UID(tmp.st_uid, stat->uid);
217         SET_GID(tmp.st_gid, stat->gid);
218 #if BITS_PER_LONG == 32
219         tmp.st_rdev = old_encode_dev(stat->rdev);
220 #else
221         tmp.st_rdev = new_encode_dev(stat->rdev);
222 #endif
223 #if BITS_PER_LONG == 32
224         if (stat->size > MAX_NON_LFS)
225                 return -EOVERFLOW;
226 #endif  
227         tmp.st_size = stat->size;
228         tmp.st_atime = stat->atime.tv_sec;
229         tmp.st_mtime = stat->mtime.tv_sec;
230         tmp.st_ctime = stat->ctime.tv_sec;
231 #ifdef STAT_HAVE_NSEC
232         tmp.st_atime_nsec = stat->atime.tv_nsec;
233         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
234         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
235 #endif
236         tmp.st_blocks = stat->blocks;
237         tmp.st_blksize = stat->blksize;
238         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
239 }
240
241 asmlinkage long sys_newstat(char __user *filename, struct stat __user *statbuf)
242 {
243         struct kstat stat;
244         int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
245
246         if (!error)
247                 error = cp_new_stat(&stat, statbuf);
248
249         return error;
250 }
251
252 asmlinkage long sys_newlstat(char __user *filename, struct stat __user *statbuf)
253 {
254         struct kstat stat;
255         int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
256
257         if (!error)
258                 error = cp_new_stat(&stat, statbuf);
259
260         return error;
261 }
262
263 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
264 asmlinkage long sys_newfstatat(int dfd, char __user *filename,
265                                 struct stat __user *statbuf, int flag)
266 {
267         struct kstat stat;
268         int error = -EINVAL;
269
270         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
271                 goto out;
272
273         if (flag & AT_SYMLINK_NOFOLLOW)
274                 error = vfs_lstat_fd(dfd, filename, &stat);
275         else
276                 error = vfs_stat_fd(dfd, filename, &stat);
277
278         if (!error)
279                 error = cp_new_stat(&stat, statbuf);
280
281 out:
282         return error;
283 }
284 #endif
285
286 asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf)
287 {
288         struct kstat stat;
289         int error = vfs_fstat(fd, &stat);
290
291         if (!error)
292                 error = cp_new_stat(&stat, statbuf);
293
294         return error;
295 }
296
297 asmlinkage long sys_readlinkat(int dfd, const char __user *path,
298                                 char __user *buf, int bufsiz)
299 {
300         struct nameidata nd;
301         int error;
302
303         if (bufsiz <= 0)
304                 return -EINVAL;
305
306         error = __user_walk_fd(dfd, path, 0, &nd);
307         if (!error) {
308                 struct inode * inode = nd.dentry->d_inode;
309
310                 error = -EINVAL;
311                 if (inode->i_op && inode->i_op->readlink) {
312                         error = security_inode_readlink(nd.dentry);
313                         if (!error) {
314                                 touch_atime(nd.mnt, nd.dentry);
315                                 error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
316                         }
317                 }
318                 path_release(&nd);
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 #ifdef STAT64_HAS_BROKEN_ST_INO
350         tmp.__st_ino = stat->ino;
351 #endif
352         tmp.st_mode = stat->mode;
353         tmp.st_nlink = stat->nlink;
354         tmp.st_uid = stat->uid;
355         tmp.st_gid = stat->gid;
356         tmp.st_atime = stat->atime.tv_sec;
357         tmp.st_atime_nsec = stat->atime.tv_nsec;
358         tmp.st_mtime = stat->mtime.tv_sec;
359         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
360         tmp.st_ctime = stat->ctime.tv_sec;
361         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
362         tmp.st_size = stat->size;
363         tmp.st_blocks = stat->blocks;
364         tmp.st_blksize = stat->blksize;
365         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
366 }
367
368 asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf)
369 {
370         struct kstat stat;
371         int error = vfs_stat(filename, &stat);
372
373         if (!error)
374                 error = cp_new_stat64(&stat, statbuf);
375
376         return error;
377 }
378 asmlinkage long sys_lstat64(char __user * filename, struct stat64 __user * statbuf)
379 {
380         struct kstat stat;
381         int error = vfs_lstat(filename, &stat);
382
383         if (!error)
384                 error = cp_new_stat64(&stat, statbuf);
385
386         return error;
387 }
388 asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf)
389 {
390         struct kstat stat;
391         int error = vfs_fstat(fd, &stat);
392
393         if (!error)
394                 error = cp_new_stat64(&stat, statbuf);
395
396         return error;
397 }
398
399 asmlinkage long sys_fstatat64(int dfd, char __user *filename,
400                                struct stat64 __user *statbuf, int flag)
401 {
402         struct kstat stat;
403         int error = -EINVAL;
404
405         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
406                 goto out;
407
408         if (flag & AT_SYMLINK_NOFOLLOW)
409                 error = vfs_lstat_fd(dfd, filename, &stat);
410         else
411                 error = vfs_stat_fd(dfd, filename, &stat);
412
413         if (!error)
414                 error = cp_new_stat64(&stat, statbuf);
415
416 out:
417         return error;
418 }
419 #endif /* __ARCH_WANT_STAT64 */
420
421 void inode_add_bytes(struct inode *inode, loff_t bytes)
422 {
423         spin_lock(&inode->i_lock);
424         inode->i_blocks += bytes >> 9;
425         bytes &= 511;
426         inode->i_bytes += bytes;
427         if (inode->i_bytes >= 512) {
428                 inode->i_blocks++;
429                 inode->i_bytes -= 512;
430         }
431         spin_unlock(&inode->i_lock);
432 }
433
434 EXPORT_SYMBOL(inode_add_bytes);
435
436 void inode_sub_bytes(struct inode *inode, loff_t bytes)
437 {
438         spin_lock(&inode->i_lock);
439         inode->i_blocks -= bytes >> 9;
440         bytes &= 511;
441         if (inode->i_bytes < bytes) {
442                 inode->i_blocks--;
443                 inode->i_bytes += 512;
444         }
445         inode->i_bytes -= bytes;
446         spin_unlock(&inode->i_lock);
447 }
448
449 EXPORT_SYMBOL(inode_sub_bytes);
450
451 loff_t inode_get_bytes(struct inode *inode)
452 {
453         loff_t ret;
454
455         spin_lock(&inode->i_lock);
456         ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
457         spin_unlock(&inode->i_lock);
458         return ret;
459 }
460
461 EXPORT_SYMBOL(inode_get_bytes);
462
463 void inode_set_bytes(struct inode *inode, loff_t bytes)
464 {
465         /* Caller is here responsible for sufficient locking
466          * (ie. inode->i_lock) */
467         inode->i_blocks = bytes >> 9;
468         inode->i_bytes = bytes & 511;
469 }
470
471 EXPORT_SYMBOL(inode_set_bytes);