fs: do not assign default i_ino in new_inode
[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_fstat(unsigned int fd, struct kstat *stat)
59 {
60         struct file *f = fget(fd);
61         int error = -EBADF;
62
63         if (f) {
64                 error = vfs_getattr(f->f_path.mnt, f->f_path.dentry, stat);
65                 fput(f);
66         }
67         return error;
68 }
69 EXPORT_SYMBOL(vfs_fstat);
70
71 int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
72                 int flag)
73 {
74         struct path path;
75         int error = -EINVAL;
76         int lookup_flags = 0;
77
78         if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
79                 goto out;
80
81         if (!(flag & AT_SYMLINK_NOFOLLOW))
82                 lookup_flags |= LOOKUP_FOLLOW;
83
84         error = user_path_at(dfd, filename, lookup_flags, &path);
85         if (error)
86                 goto out;
87
88         error = vfs_getattr(path.mnt, path.dentry, stat);
89         path_put(&path);
90 out:
91         return error;
92 }
93 EXPORT_SYMBOL(vfs_fstatat);
94
95 int vfs_stat(const char __user *name, struct kstat *stat)
96 {
97         return vfs_fstatat(AT_FDCWD, name, stat, 0);
98 }
99 EXPORT_SYMBOL(vfs_stat);
100
101 int vfs_lstat(const char __user *name, struct kstat *stat)
102 {
103         return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
104 }
105 EXPORT_SYMBOL(vfs_lstat);
106
107
108 #ifdef __ARCH_WANT_OLD_STAT
109
110 /*
111  * For backward compatibility?  Maybe this should be moved
112  * into arch/i386 instead?
113  */
114 static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
115 {
116         static int warncount = 5;
117         struct __old_kernel_stat tmp;
118         
119         if (warncount > 0) {
120                 warncount--;
121                 printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
122                         current->comm);
123         } else if (warncount < 0) {
124                 /* it's laughable, but... */
125                 warncount = 0;
126         }
127
128         memset(&tmp, 0, sizeof(struct __old_kernel_stat));
129         tmp.st_dev = old_encode_dev(stat->dev);
130         tmp.st_ino = stat->ino;
131         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
132                 return -EOVERFLOW;
133         tmp.st_mode = stat->mode;
134         tmp.st_nlink = stat->nlink;
135         if (tmp.st_nlink != stat->nlink)
136                 return -EOVERFLOW;
137         SET_UID(tmp.st_uid, stat->uid);
138         SET_GID(tmp.st_gid, stat->gid);
139         tmp.st_rdev = old_encode_dev(stat->rdev);
140 #if BITS_PER_LONG == 32
141         if (stat->size > MAX_NON_LFS)
142                 return -EOVERFLOW;
143 #endif  
144         tmp.st_size = stat->size;
145         tmp.st_atime = stat->atime.tv_sec;
146         tmp.st_mtime = stat->mtime.tv_sec;
147         tmp.st_ctime = stat->ctime.tv_sec;
148         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
149 }
150
151 SYSCALL_DEFINE2(stat, const char __user *, filename,
152                 struct __old_kernel_stat __user *, statbuf)
153 {
154         struct kstat stat;
155         int error;
156
157         error = vfs_stat(filename, &stat);
158         if (error)
159                 return error;
160
161         return cp_old_stat(&stat, statbuf);
162 }
163
164 SYSCALL_DEFINE2(lstat, const char __user *, filename,
165                 struct __old_kernel_stat __user *, statbuf)
166 {
167         struct kstat stat;
168         int error;
169
170         error = vfs_lstat(filename, &stat);
171         if (error)
172                 return error;
173
174         return cp_old_stat(&stat, statbuf);
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, const char __user *, filename,
241                 struct stat __user *, statbuf)
242 {
243         struct kstat stat;
244         int error = vfs_stat(filename, &stat);
245
246         if (error)
247                 return error;
248         return cp_new_stat(&stat, statbuf);
249 }
250
251 SYSCALL_DEFINE2(newlstat, const char __user *, filename,
252                 struct stat __user *, statbuf)
253 {
254         struct kstat stat;
255         int error;
256
257         error = vfs_lstat(filename, &stat);
258         if (error)
259                 return error;
260
261         return cp_new_stat(&stat, statbuf);
262 }
263
264 #if !defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_SYS_NEWFSTATAT)
265 SYSCALL_DEFINE4(newfstatat, int, dfd, const char __user *, filename,
266                 struct stat __user *, statbuf, int, flag)
267 {
268         struct kstat stat;
269         int error;
270
271         error = vfs_fstatat(dfd, filename, &stat, flag);
272         if (error)
273                 return error;
274         return cp_new_stat(&stat, statbuf);
275 }
276 #endif
277
278 SYSCALL_DEFINE2(newfstat, unsigned int, fd, struct stat __user *, statbuf)
279 {
280         struct kstat stat;
281         int error = vfs_fstat(fd, &stat);
282
283         if (!error)
284                 error = cp_new_stat(&stat, statbuf);
285
286         return error;
287 }
288
289 SYSCALL_DEFINE4(readlinkat, int, dfd, const char __user *, pathname,
290                 char __user *, buf, int, bufsiz)
291 {
292         struct path path;
293         int error;
294
295         if (bufsiz <= 0)
296                 return -EINVAL;
297
298         error = user_path_at(dfd, pathname, 0, &path);
299         if (!error) {
300                 struct inode *inode = path.dentry->d_inode;
301
302                 error = -EINVAL;
303                 if (inode->i_op->readlink) {
304                         error = security_inode_readlink(path.dentry);
305                         if (!error) {
306                                 touch_atime(path.mnt, path.dentry);
307                                 error = inode->i_op->readlink(path.dentry,
308                                                               buf, bufsiz);
309                         }
310                 }
311                 path_put(&path);
312         }
313         return error;
314 }
315
316 SYSCALL_DEFINE3(readlink, const char __user *, path, char __user *, buf,
317                 int, bufsiz)
318 {
319         return sys_readlinkat(AT_FDCWD, path, buf, bufsiz);
320 }
321
322
323 /* ---------- LFS-64 ----------- */
324 #ifdef __ARCH_WANT_STAT64
325
326 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
327 {
328         struct stat64 tmp;
329
330         memset(&tmp, 0, sizeof(struct stat64));
331 #ifdef CONFIG_MIPS
332         /* mips has weird padding, so we don't get 64 bits there */
333         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
334                 return -EOVERFLOW;
335         tmp.st_dev = new_encode_dev(stat->dev);
336         tmp.st_rdev = new_encode_dev(stat->rdev);
337 #else
338         tmp.st_dev = huge_encode_dev(stat->dev);
339         tmp.st_rdev = huge_encode_dev(stat->rdev);
340 #endif
341         tmp.st_ino = stat->ino;
342         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
343                 return -EOVERFLOW;
344 #ifdef STAT64_HAS_BROKEN_ST_INO
345         tmp.__st_ino = stat->ino;
346 #endif
347         tmp.st_mode = stat->mode;
348         tmp.st_nlink = stat->nlink;
349         tmp.st_uid = stat->uid;
350         tmp.st_gid = stat->gid;
351         tmp.st_atime = stat->atime.tv_sec;
352         tmp.st_atime_nsec = stat->atime.tv_nsec;
353         tmp.st_mtime = stat->mtime.tv_sec;
354         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
355         tmp.st_ctime = stat->ctime.tv_sec;
356         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
357         tmp.st_size = stat->size;
358         tmp.st_blocks = stat->blocks;
359         tmp.st_blksize = stat->blksize;
360         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
361 }
362
363 SYSCALL_DEFINE2(stat64, const char __user *, filename,
364                 struct stat64 __user *, statbuf)
365 {
366         struct kstat stat;
367         int error = vfs_stat(filename, &stat);
368
369         if (!error)
370                 error = cp_new_stat64(&stat, statbuf);
371
372         return error;
373 }
374
375 SYSCALL_DEFINE2(lstat64, const char __user *, filename,
376                 struct stat64 __user *, statbuf)
377 {
378         struct kstat stat;
379         int error = vfs_lstat(filename, &stat);
380
381         if (!error)
382                 error = cp_new_stat64(&stat, statbuf);
383
384         return error;
385 }
386
387 SYSCALL_DEFINE2(fstat64, unsigned long, fd, struct stat64 __user *, statbuf)
388 {
389         struct kstat stat;
390         int error = vfs_fstat(fd, &stat);
391
392         if (!error)
393                 error = cp_new_stat64(&stat, statbuf);
394
395         return error;
396 }
397
398 SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
399                 struct stat64 __user *, statbuf, int, flag)
400 {
401         struct kstat stat;
402         int error;
403
404         error = vfs_fstatat(dfd, filename, &stat, flag);
405         if (error)
406                 return error;
407         return cp_new_stat64(&stat, statbuf);
408 }
409 #endif /* __ARCH_WANT_STAT64 */
410
411 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
412 void __inode_add_bytes(struct inode *inode, loff_t bytes)
413 {
414         inode->i_blocks += bytes >> 9;
415         bytes &= 511;
416         inode->i_bytes += bytes;
417         if (inode->i_bytes >= 512) {
418                 inode->i_blocks++;
419                 inode->i_bytes -= 512;
420         }
421 }
422
423 void inode_add_bytes(struct inode *inode, loff_t bytes)
424 {
425         spin_lock(&inode->i_lock);
426         __inode_add_bytes(inode, bytes);
427         spin_unlock(&inode->i_lock);
428 }
429
430 EXPORT_SYMBOL(inode_add_bytes);
431
432 void inode_sub_bytes(struct inode *inode, loff_t bytes)
433 {
434         spin_lock(&inode->i_lock);
435         inode->i_blocks -= bytes >> 9;
436         bytes &= 511;
437         if (inode->i_bytes < bytes) {
438                 inode->i_blocks--;
439                 inode->i_bytes += 512;
440         }
441         inode->i_bytes -= bytes;
442         spin_unlock(&inode->i_lock);
443 }
444
445 EXPORT_SYMBOL(inode_sub_bytes);
446
447 loff_t inode_get_bytes(struct inode *inode)
448 {
449         loff_t ret;
450
451         spin_lock(&inode->i_lock);
452         ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
453         spin_unlock(&inode->i_lock);
454         return ret;
455 }
456
457 EXPORT_SYMBOL(inode_get_bytes);
458
459 void inode_set_bytes(struct inode *inode, loff_t bytes)
460 {
461         /* Caller is here responsible for sufficient locking
462          * (ie. inode->i_lock) */
463         inode->i_blocks = bytes >> 9;
464         inode->i_bytes = bytes & 511;
465 }
466
467 EXPORT_SYMBOL(inode_set_bytes);