Separate out common fstatat code into vfs_fstatat
[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 int vfs_fstatat(int dfd, char __user *filename, struct kstat *stat, int flag)
113 {
114         int error = -EINVAL;
115
116         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
117                 goto out;
118
119         if (flag & AT_SYMLINK_NOFOLLOW)
120                 error = vfs_lstat_fd(dfd, filename, stat);
121         else
122                 error = vfs_stat_fd(dfd, filename, stat);
123 out:
124         return error;
125 }
126
127 EXPORT_SYMBOL(vfs_fstatat);
128
129
130 #ifdef __ARCH_WANT_OLD_STAT
131
132 /*
133  * For backward compatibility?  Maybe this should be moved
134  * into arch/i386 instead?
135  */
136 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
137 {
138         static int warncount = 5;
139         struct __old_kernel_stat tmp;
140         
141         if (warncount > 0) {
142                 warncount--;
143                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
144                         current->comm);
145         } else if (warncount < 0) {
146                 /* it's laughable, but... */
147                 warncount = 0;
148         }
149
150         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
151         tmp.st_dev = old_encode_dev(stat->dev);
152         tmp.st_ino = stat->ino;
153         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
154                 return -EOVERFLOW;
155         tmp.st_mode = stat->mode;
156         tmp.st_nlink = stat->nlink;
157         if (tmp.st_nlink != stat->nlink)
158                 return -EOVERFLOW;
159         SET_UID(tmp.st_uid, stat->uid);
160         SET_GID(tmp.st_gid, stat->gid);
161         tmp.st_rdev = old_encode_dev(stat->rdev);
162 #if BITS_PER_LONG == 32
163         if (stat->size > MAX_NON_LFS)
164                 return -EOVERFLOW;
165 #endif  
166         tmp.st_size = stat->size;
167         tmp.st_atime = stat->atime.tv_sec;
168         tmp.st_mtime = stat->mtime.tv_sec;
169         tmp.st_ctime = stat->ctime.tv_sec;
170         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
171 }
172
173 SYSCALL_DEFINE2(stat, char __user *, filename, struct __old_kernel_stat __user *, statbuf)
174 {
175         struct kstat stat;
176         int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
177
178         if (!error)
179                 error = cp_old_stat(&stat, statbuf);
180
181         return error;
182 }
183
184 SYSCALL_DEFINE2(lstat, char __user *, filename, struct __old_kernel_stat __user *, statbuf)
185 {
186         struct kstat stat;
187         int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
188
189         if (!error)
190                 error = cp_old_stat(&stat, statbuf);
191
192         return error;
193 }
194
195 SYSCALL_DEFINE2(fstat, unsigned int, fd, struct __old_kernel_stat __user *, statbuf)
196 {
197         struct kstat stat;
198         int error = vfs_fstat(fd, &stat);
199
200         if (!error)
201                 error = cp_old_stat(&stat, statbuf);
202
203         return error;
204 }
205
206 #endif /* __ARCH_WANT_OLD_STAT */
207
208 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
209 {
210         struct stat tmp;
211
212 #if BITS_PER_LONG == 32
213         if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
214                 return -EOVERFLOW;
215 #else
216         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
217                 return -EOVERFLOW;
218 #endif
219
220         memset(&tmp, 0, sizeof(tmp));
221 #if BITS_PER_LONG == 32
222         tmp.st_dev = old_encode_dev(stat->dev);
223 #else
224         tmp.st_dev = new_encode_dev(stat->dev);
225 #endif
226         tmp.st_ino = stat->ino;
227         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
228                 return -EOVERFLOW;
229         tmp.st_mode = stat->mode;
230         tmp.st_nlink = stat->nlink;
231         if (tmp.st_nlink != stat->nlink)
232                 return -EOVERFLOW;
233         SET_UID(tmp.st_uid, stat->uid);
234         SET_GID(tmp.st_gid, stat->gid);
235 #if BITS_PER_LONG == 32
236         tmp.st_rdev = old_encode_dev(stat->rdev);
237 #else
238         tmp.st_rdev = new_encode_dev(stat->rdev);
239 #endif
240 #if BITS_PER_LONG == 32
241         if (stat->size > MAX_NON_LFS)
242                 return -EOVERFLOW;
243 #endif  
244         tmp.st_size = stat->size;
245         tmp.st_atime = stat->atime.tv_sec;
246         tmp.st_mtime = stat->mtime.tv_sec;
247         tmp.st_ctime = stat->ctime.tv_sec;
248 #ifdef STAT_HAVE_NSEC
249         tmp.st_atime_nsec = stat->atime.tv_nsec;
250         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
251         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
252 #endif
253         tmp.st_blocks = stat->blocks;
254         tmp.st_blksize = stat->blksize;
255         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
256 }
257
258 SYSCALL_DEFINE2(newstat, char __user *, filename, struct stat __user *, statbuf)
259 {
260         struct kstat stat;
261         int error = vfs_stat_fd(AT_FDCWD, filename, &stat);
262
263         if (!error)
264                 error = cp_new_stat(&stat, statbuf);
265
266         return error;
267 }
268
269 SYSCALL_DEFINE2(newlstat, char __user *, filename, struct stat __user *, statbuf)
270 {
271         struct kstat stat;
272         int error = vfs_lstat_fd(AT_FDCWD, filename, &stat);
273
274         if (!error)
275                 error = cp_new_stat(&stat, statbuf);
276
277         return error;
278 }
279
280 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
281 SYSCALL_DEFINE4(newfstatat, int, dfd, char __user *, filename,
282                 struct stat __user *, statbuf, int, flag)
283 {
284         struct kstat stat;
285         int error;
286
287         error = vfs_fstatat(dfd, filename, &stat, flag);
288         if (error)
289                 return error;
290         return cp_new_stat(&stat, statbuf);
291 }
292 #endif
293
294 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
295 {
296         struct kstat stat;
297         int error = vfs_fstat(fd, &stat);
298
299         if (!error)
300                 error = cp_new_stat(&stat, statbuf);
301
302         return error;
303 }
304
305 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
306                 char __user *, buf, int, bufsiz)
307 {
308         struct path path;
309         int error;
310
311         if (bufsiz <= 0)
312                 return -EINVAL;
313
314         error = user_path_at(dfd, pathname, 0, &path);
315         if (!error) {
316                 struct inode *inode = path.dentry->d_inode;
317
318                 error = -EINVAL;
319                 if (inode->i_op->readlink) {
320                         error = security_inode_readlink(path.dentry);
321                         if (!error) {
322                                 touch_atime(path.mnt, path.dentry);
323                                 error = inode->i_op->readlink(path.dentry,
324                                                               buf, bufsiz);
325                         }
326                 }
327                 path_put(&path);
328         }
329         return error;
330 }
331
332 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
333                 int, bufsiz)
334 {
335         return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
336 }
337
338
339 /* ---------- LFS-64 ----------- */
340 #ifdef __ARCH_WANT_STAT64
341
342 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
343 {
344         struct stat64 tmp;
345
346         memset(&tmp, 0, sizeof(struct stat64));
347 #ifdef CONFIG_MIPS
348         /* mips has weird padding, so we don't get 64 bits there */
349         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
350                 return -EOVERFLOW;
351         tmp.st_dev = new_encode_dev(stat->dev);
352         tmp.st_rdev = new_encode_dev(stat->rdev);
353 #else
354         tmp.st_dev = huge_encode_dev(stat->dev);
355         tmp.st_rdev = huge_encode_dev(stat->rdev);
356 #endif
357         tmp.st_ino = stat->ino;
358         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
359                 return -EOVERFLOW;
360 #ifdef STAT64_HAS_BROKEN_ST_INO
361         tmp.__st_ino = stat->ino;
362 #endif
363         tmp.st_mode = stat->mode;
364         tmp.st_nlink = stat->nlink;
365         tmp.st_uid = stat->uid;
366         tmp.st_gid = stat->gid;
367         tmp.st_atime = stat->atime.tv_sec;
368         tmp.st_atime_nsec = stat->atime.tv_nsec;
369         tmp.st_mtime = stat->mtime.tv_sec;
370         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
371         tmp.st_ctime = stat->ctime.tv_sec;
372         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
373         tmp.st_size = stat->size;
374         tmp.st_blocks = stat->blocks;
375         tmp.st_blksize = stat->blksize;
376         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
377 }
378
379 SYSCALL_DEFINE2(stat64, char __user *, filename, struct stat64 __user *, statbuf)
380 {
381         struct kstat stat;
382         int error = vfs_stat(filename, &stat);
383
384         if (!error)
385                 error = cp_new_stat64(&stat, statbuf);
386
387         return error;
388 }
389
390 SYSCALL_DEFINE2(lstat64, char __user *, filename, struct stat64 __user *, statbuf)
391 {
392         struct kstat stat;
393         int error = vfs_lstat(filename, &stat);
394
395         if (!error)
396                 error = cp_new_stat64(&stat, statbuf);
397
398         return error;
399 }
400
401 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
402 {
403         struct kstat stat;
404         int error = vfs_fstat(fd, &stat);
405
406         if (!error)
407                 error = cp_new_stat64(&stat, statbuf);
408
409         return error;
410 }
411
412 SYSCALL_DEFINE4(fstatat64, int, dfd, char __user *, filename,
413                 struct stat64 __user *, statbuf, int, flag)
414 {
415         struct kstat stat;
416         int error;
417
418         error = vfs_fstatat(dfd, filename, &stat, flag);
419         if (error)
420                 return error;
421         return cp_new_stat64(&stat, statbuf);
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);