ia64/linux-2.6.18-xen.hg

view fs/stat.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
1 /*
2 * linux/fs/stat.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
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>
18 #include <asm/uaccess.h>
19 #include <asm/unistd.h>
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 }
38 EXPORT_SYMBOL(generic_fillattr);
40 int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
41 {
42 struct inode *inode = dentry->d_inode;
43 int retval;
45 retval = security_inode_getattr(mnt, dentry);
46 if (retval)
47 return retval;
49 if (inode->i_op->getattr)
50 return inode->i_op->getattr(mnt, dentry, stat);
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 }
63 EXPORT_SYMBOL(vfs_getattr);
65 int vfs_stat_fd(int dfd, char __user *name, struct kstat *stat)
66 {
67 struct nameidata nd;
68 int error;
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 }
78 int vfs_stat(char __user *name, struct kstat *stat)
79 {
80 return vfs_stat_fd(AT_FDCWD, name, stat);
81 }
83 EXPORT_SYMBOL(vfs_stat);
85 int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat)
86 {
87 struct nameidata nd;
88 int error;
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 }
98 int vfs_lstat(char __user *name, struct kstat *stat)
99 {
100 return vfs_lstat_fd(AT_FDCWD, name, stat);
101 }
103 EXPORT_SYMBOL(vfs_lstat);
105 int vfs_fstat(unsigned int fd, struct kstat *stat)
106 {
107 struct file *f = fget(fd);
108 int error = -EBADF;
110 if (f) {
111 error = vfs_getattr(f->f_vfsmnt, f->f_dentry, stat);
112 fput(f);
113 }
114 return error;
115 }
117 EXPORT_SYMBOL(vfs_fstat);
119 #ifdef __ARCH_WANT_OLD_STAT
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;
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 }
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 }
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);
165 if (!error)
166 error = cp_old_stat(&stat, statbuf);
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);
175 if (!error)
176 error = cp_old_stat(&stat, statbuf);
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);
185 if (!error)
186 error = cp_old_stat(&stat, statbuf);
188 return error;
189 }
191 #endif /* __ARCH_WANT_OLD_STAT */
193 static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
194 {
195 struct stat tmp;
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
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 }
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);
246 if (!error)
247 error = cp_new_stat(&stat, statbuf);
249 return error;
250 }
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);
257 if (!error)
258 error = cp_new_stat(&stat, statbuf);
260 return error;
261 }
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;
270 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
271 goto out;
273 if (flag & AT_SYMLINK_NOFOLLOW)
274 error = vfs_lstat_fd(dfd, filename, &stat);
275 else
276 error = vfs_stat_fd(dfd, filename, &stat);
278 if (!error)
279 error = cp_new_stat(&stat, statbuf);
281 out:
282 return error;
283 }
284 #endif
286 asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf)
287 {
288 struct kstat stat;
289 int error = vfs_fstat(fd, &stat);
291 if (!error)
292 error = cp_new_stat(&stat, statbuf);
294 return error;
295 }
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;
303 if (bufsiz <= 0)
304 return -EINVAL;
306 error = __user_walk_fd(dfd, path, 0, &nd);
307 if (!error) {
308 struct inode * inode = nd.dentry->d_inode;
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 }
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 }
330 /* ---------- LFS-64 ----------- */
331 #ifdef __ARCH_WANT_STAT64
333 static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
334 {
335 struct stat64 tmp;
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 }
368 asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf)
369 {
370 struct kstat stat;
371 int error = vfs_stat(filename, &stat);
373 if (!error)
374 error = cp_new_stat64(&stat, statbuf);
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);
383 if (!error)
384 error = cp_new_stat64(&stat, statbuf);
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);
393 if (!error)
394 error = cp_new_stat64(&stat, statbuf);
396 return error;
397 }
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;
405 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
406 goto out;
408 if (flag & AT_SYMLINK_NOFOLLOW)
409 error = vfs_lstat_fd(dfd, filename, &stat);
410 else
411 error = vfs_stat_fd(dfd, filename, &stat);
413 if (!error)
414 error = cp_new_stat64(&stat, statbuf);
416 out:
417 return error;
418 }
419 #endif /* __ARCH_WANT_STAT64 */
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 }
434 EXPORT_SYMBOL(inode_add_bytes);
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 }
449 EXPORT_SYMBOL(inode_sub_bytes);
451 loff_t inode_get_bytes(struct inode *inode)
452 {
453 loff_t ret;
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 }
461 EXPORT_SYMBOL(inode_get_bytes);
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 }
471 EXPORT_SYMBOL(inode_set_bytes);