[net-next-2.6.git] / fs / stat.c

/*
 *  linux/fs/stat.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/file.h>
#include <linux/smp_lock.h>
#include <linux/highuid.h>
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/security.h>
#include <linux/syscalls.h>

#include <asm/uaccess.h>
#include <asm/unistd.h>

void generic_fillattr(struct inode *inode, struct kstat *stat)
{
	stat->dev = inode->i_sb->s_dev;
	stat->ino = inode->i_ino;
	stat->mode = inode->i_mode;
	stat->nlink = inode->i_nlink;
	stat->uid = inode->i_uid;
	stat->gid = inode->i_gid;
	stat->rdev = inode->i_rdev;
	stat->atime = inode->i_atime;
	stat->mtime = inode->i_mtime;
	stat->ctime = inode->i_ctime;
	stat->size = i_size_read(inode);
	stat->blocks = inode->i_blocks;
	stat->blksize = inode->i_blksize;
}

EXPORT_SYMBOL(generic_fillattr);

int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
	int retval;

	retval = security_inode_getattr(mnt, dentry);
	if (retval)
		return retval;

	if (inode->i_op->getattr)
		return inode->i_op->getattr(mnt, dentry, stat);

	generic_fillattr(inode, stat);
	if (!stat->blksize) {
		struct super_block *s = inode->i_sb;
		unsigned blocks;
		blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
		stat->blocks = (s->s_blocksize / 512) * blocks;
		stat->blksize = s->s_blocksize;
	}
	return 0;
}

EXPORT_SYMBOL(vfs_getattr);

int vfs_stat(char __user *name, struct kstat *stat)
{
	struct nameidata nd;
	int error;

	error = user_path_walk(name, &nd);
	if (!error) {
		error = vfs_getattr(nd.mnt, nd.dentry, stat);
		path_release(&nd);
	}
	return error;
}

EXPORT_SYMBOL(vfs_stat);

int vfs_lstat(char __user *name, struct kstat *stat)
{
	struct nameidata nd;
	int error;

	error = user_path_walk_link(name, &nd);
	if (!error) {
		error = vfs_getattr(nd.mnt, nd.dentry, stat);
		path_release(&nd);
	}
	return error;
}

EXPORT_SYMBOL(vfs_lstat);

int vfs_fstat(unsigned int fd, struct kstat *stat)
{
	struct file *f = fget(fd);
	int error = -EBADF;

	if (f) {
		error = vfs_getattr(f->f_vfsmnt, f->f_dentry, stat);
		fput(f);
	}
	return error;
}

EXPORT_SYMBOL(vfs_fstat);

#ifdef __ARCH_WANT_OLD_STAT

/*
 * For backward compatibility?  Maybe this should be moved
 * into arch/i386 instead?
 */
static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * statbuf)
{
	static int warncount = 5;
	struct __old_kernel_stat tmp;
	
	if (warncount > 0) {
		warncount--;
		printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
			current->comm);
	} else if (warncount < 0) {
		/* it's laughable, but... */
		warncount = 0;
	}

	memset(&tmp, 0, sizeof(struct __old_kernel_stat));
	tmp.st_dev = old_encode_dev(stat->dev);
	tmp.st_ino = stat->ino;
	tmp.st_mode = stat->mode;
	tmp.st_nlink = stat->nlink;
	if (tmp.st_nlink != stat->nlink)
		return -EOVERFLOW;
	SET_UID(tmp.st_uid, stat->uid);
	SET_GID(tmp.st_gid, stat->gid);
	tmp.st_rdev = old_encode_dev(stat->rdev);
#if BITS_PER_LONG == 32
	if (stat->size > MAX_NON_LFS)
		return -EOVERFLOW;
#endif	
	tmp.st_size = stat->size;
	tmp.st_atime = stat->atime.tv_sec;
	tmp.st_mtime = stat->mtime.tv_sec;
	tmp.st_ctime = stat->ctime.tv_sec;
	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
}

asmlinkage long sys_stat(char __user * filename, struct __old_kernel_stat __user * statbuf)
{
	struct kstat stat;
	int error = vfs_stat(filename, &stat);

	if (!error)
		error = cp_old_stat(&stat, statbuf);

	return error;
}
asmlinkage long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
{
	struct kstat stat;
	int error = vfs_lstat(filename, &stat);

	if (!error)
		error = cp_old_stat(&stat, statbuf);

	return error;
}
asmlinkage long sys_fstat(unsigned int fd, struct __old_kernel_stat __user * statbuf)
{
	struct kstat stat;
	int error = vfs_fstat(fd, &stat);

	if (!error)
		error = cp_old_stat(&stat, statbuf);

	return error;
}

#endif /* __ARCH_WANT_OLD_STAT */

static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
{
	struct stat tmp;

#if BITS_PER_LONG == 32
	if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
		return -EOVERFLOW;
#else
	if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
		return -EOVERFLOW;
#endif

	memset(&tmp, 0, sizeof(tmp));
#if BITS_PER_LONG == 32
	tmp.st_dev = old_encode_dev(stat->dev);
#else
	tmp.st_dev = new_encode_dev(stat->dev);
#endif
	tmp.st_ino = stat->ino;
	tmp.st_mode = stat->mode;
	tmp.st_nlink = stat->nlink;
	if (tmp.st_nlink != stat->nlink)
		return -EOVERFLOW;
	SET_UID(tmp.st_uid, stat->uid);
	SET_GID(tmp.st_gid, stat->gid);
#if BITS_PER_LONG == 32
	tmp.st_rdev = old_encode_dev(stat->rdev);
#else
	tmp.st_rdev = new_encode_dev(stat->rdev);
#endif
#if BITS_PER_LONG == 32
	if (stat->size > MAX_NON_LFS)
		return -EOVERFLOW;
#endif	
	tmp.st_size = stat->size;
	tmp.st_atime = stat->atime.tv_sec;
	tmp.st_mtime = stat->mtime.tv_sec;
	tmp.st_ctime = stat->ctime.tv_sec;
#ifdef STAT_HAVE_NSEC
	tmp.st_atime_nsec = stat->atime.tv_nsec;
	tmp.st_mtime_nsec = stat->mtime.tv_nsec;
	tmp.st_ctime_nsec = stat->ctime.tv_nsec;
#endif
	tmp.st_blocks = stat->blocks;
	tmp.st_blksize = stat->blksize;
	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
}

asmlinkage long sys_newstat(char __user * filename, struct stat __user * statbuf)
{
	struct kstat stat;
	int error = vfs_stat(filename, &stat);

	if (!error)
		error = cp_new_stat(&stat, statbuf);

	return error;
}
asmlinkage long sys_newlstat(char __user * filename, struct stat __user * statbuf)
{
	struct kstat stat;
	int error = vfs_lstat(filename, &stat);

	if (!error)
		error = cp_new_stat(&stat, statbuf);

	return error;
}
asmlinkage long sys_newfstat(unsigned int fd, struct stat __user * statbuf)
{
	struct kstat stat;
	int error = vfs_fstat(fd, &stat);

	if (!error)
		error = cp_new_stat(&stat, statbuf);

	return error;
}

asmlinkage long sys_readlink(const char __user * path, char __user * buf, int bufsiz)
{
	struct nameidata nd;
	int error;

	if (bufsiz <= 0)
		return -EINVAL;

	error = user_path_walk_link(path, &nd);
	if (!error) {
		struct inode * inode = nd.dentry->d_inode;

		error = -EINVAL;
		if (inode->i_op && inode->i_op->readlink) {
			error = security_inode_readlink(nd.dentry);
			if (!error) {
				touch_atime(nd.mnt, nd.dentry);
				error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
			}
		}
		path_release(&nd);
	}
	return error;
}


/* ---------- LFS-64 ----------- */
#ifdef __ARCH_WANT_STAT64

static long cp_new_stat64(struct kstat *stat, struct stat64 __user *statbuf)
{
	struct stat64 tmp;

	memset(&tmp, 0, sizeof(struct stat64));
#ifdef CONFIG_MIPS
	/* mips has weird padding, so we don't get 64 bits there */
	if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
		return -EOVERFLOW;
	tmp.st_dev = new_encode_dev(stat->dev);
	tmp.st_rdev = new_encode_dev(stat->rdev);
#else
	tmp.st_dev = huge_encode_dev(stat->dev);
	tmp.st_rdev = huge_encode_dev(stat->rdev);
#endif
	tmp.st_ino = stat->ino;
#ifdef STAT64_HAS_BROKEN_ST_INO
	tmp.__st_ino = stat->ino;
#endif
	tmp.st_mode = stat->mode;
	tmp.st_nlink = stat->nlink;
	tmp.st_uid = stat->uid;
	tmp.st_gid = stat->gid;
	tmp.st_atime = stat->atime.tv_sec;
	tmp.st_atime_nsec = stat->atime.tv_nsec;
	tmp.st_mtime = stat->mtime.tv_sec;
	tmp.st_mtime_nsec = stat->mtime.tv_nsec;
	tmp.st_ctime = stat->ctime.tv_sec;
	tmp.st_ctime_nsec = stat->ctime.tv_nsec;
	tmp.st_size = stat->size;
	tmp.st_blocks = stat->blocks;
	tmp.st_blksize = stat->blksize;
	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
}

asmlinkage long sys_stat64(char __user * filename, struct stat64 __user * statbuf)
{
	struct kstat stat;
	int error = vfs_stat(filename, &stat);

	if (!error)
		error = cp_new_stat64(&stat, statbuf);

	return error;
}
asmlinkage long sys_lstat64(char __user * filename, struct stat64 __user * statbuf)
{
	struct kstat stat;
	int error = vfs_lstat(filename, &stat);

	if (!error)
		error = cp_new_stat64(&stat, statbuf);

	return error;
}
asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf)
{
	struct kstat stat;
	int error = vfs_fstat(fd, &stat);

	if (!error)
		error = cp_new_stat64(&stat, statbuf);

	return error;
}

#endif /* __ARCH_WANT_STAT64 */

void inode_add_bytes(struct inode *inode, loff_t bytes)
{
	spin_lock(&inode->i_lock);
	inode->i_blocks += bytes >> 9;
	bytes &= 511;
	inode->i_bytes += bytes;
	if (inode->i_bytes >= 512) {
		inode->i_blocks++;
		inode->i_bytes -= 512;
	}
	spin_unlock(&inode->i_lock);
}

EXPORT_SYMBOL(inode_add_bytes);

void inode_sub_bytes(struct inode *inode, loff_t bytes)
{
	spin_lock(&inode->i_lock);
	inode->i_blocks -= bytes >> 9;
	bytes &= 511;
	if (inode->i_bytes < bytes) {
		inode->i_blocks--;
		inode->i_bytes += 512;
	}
	inode->i_bytes -= bytes;
	spin_unlock(&inode->i_lock);
}

EXPORT_SYMBOL(inode_sub_bytes);

loff_t inode_get_bytes(struct inode *inode)
{
	loff_t ret;

	spin_lock(&inode->i_lock);
	ret = (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
	spin_unlock(&inode->i_lock);
	return ret;
}

EXPORT_SYMBOL(inode_get_bytes);

void inode_set_bytes(struct inode *inode, loff_t bytes)
{
	/* Caller is here responsible for sufficient locking
	 * (ie. inode->i_lock) */
	inode->i_blocks = bytes >> 9;
	inode->i_bytes = bytes & 511;
}

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