libfs.c 31.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 *	fs/libfs.c
 *	Library for filesystems writers.
 */

6
#include <linux/blkdev.h>
7
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
8
#include <linux/pagemap.h>
9
#include <linux/slab.h>
10
#include <linux/cred.h>
Linus Torvalds's avatar
Linus Torvalds committed
11 12
#include <linux/mount.h>
#include <linux/vfs.h>
13
#include <linux/quotaops.h>
14
#include <linux/mutex.h>
Al Viro's avatar
Al Viro committed
15
#include <linux/namei.h>
16
#include <linux/exportfs.h>
Al Viro's avatar
Al Viro committed
17
#include <linux/writeback.h>
Al Viro's avatar
Al Viro committed
18
#include <linux/buffer_head.h> /* sync_mapping_buffers */
19

20
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
21

22 23
#include "internal.h"

24 25
int simple_getattr(const struct path *path, struct kstat *stat,
		   u32 request_mask, unsigned int query_flags)
Linus Torvalds's avatar
Linus Torvalds committed
26
{
27
	struct inode *inode = d_inode(path->dentry);
Linus Torvalds's avatar
Linus Torvalds committed
28
	generic_fillattr(inode, stat);
29
	stat->blocks = inode->i_mapping->nrpages << (PAGE_SHIFT - 9);
Linus Torvalds's avatar
Linus Torvalds committed
30 31
	return 0;
}
32
EXPORT_SYMBOL(simple_getattr);
Linus Torvalds's avatar
Linus Torvalds committed
33

34
int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds's avatar
Linus Torvalds committed
35
{
36
	buf->f_type = dentry->d_sb->s_magic;
37
	buf->f_bsize = PAGE_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40
	buf->f_namelen = NAME_MAX;
	return 0;
}
41
EXPORT_SYMBOL(simple_statfs);
Linus Torvalds's avatar
Linus Torvalds committed
42 43 44 45 46

/*
 * Retaining negative dentries for an in-memory filesystem just wastes
 * memory and lookup time: arrange for them to be deleted immediately.
 */
47
int always_delete_dentry(const struct dentry *dentry)
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50
{
	return 1;
}
51 52 53 54 55 56
EXPORT_SYMBOL(always_delete_dentry);

const struct dentry_operations simple_dentry_operations = {
	.d_delete = always_delete_dentry,
};
EXPORT_SYMBOL(simple_dentry_operations);
Linus Torvalds's avatar
Linus Torvalds committed
57 58 59 60 61

/*
 * Lookup the data. This is trivial - if the dentry didn't already
 * exist, we know it is negative.  Set d_op to delete negative dentries.
 */
62
struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
63 64 65
{
	if (dentry->d_name.len > NAME_MAX)
		return ERR_PTR(-ENAMETOOLONG);
66 67
	if (!dentry->d_sb->s_d_op)
		d_set_d_op(dentry, &simple_dentry_operations);
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70
	d_add(dentry, NULL);
	return NULL;
}
71
EXPORT_SYMBOL(simple_lookup);
Linus Torvalds's avatar
Linus Torvalds committed
72 73 74

int dcache_dir_open(struct inode *inode, struct file *file)
{
Al Viro's avatar
Al Viro committed
75
	file->private_data = d_alloc_cursor(file->f_path.dentry);
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78

	return file->private_data ? 0 : -ENOMEM;
}
79
EXPORT_SYMBOL(dcache_dir_open);
Linus Torvalds's avatar
Linus Torvalds committed
80 81 82 83 84 85

int dcache_dir_close(struct inode *inode, struct file *file)
{
	dput(file->private_data);
	return 0;
}
86
EXPORT_SYMBOL(dcache_dir_close);
Linus Torvalds's avatar
Linus Torvalds committed
87

88 89 90 91 92
/* parent is locked at least shared */
static struct dentry *next_positive(struct dentry *parent,
				    struct list_head *from,
				    int count)
{
Al Viro's avatar
Al Viro committed
93 94
	unsigned *seq = &parent->d_inode->i_dir_seq, n;
	struct dentry *res;
95
	struct list_head *p;
Al Viro's avatar
Al Viro committed
96 97 98 99 100 101 102 103 104
	bool skipped;
	int i;

retry:
	i = count;
	skipped = false;
	n = smp_load_acquire(seq) & ~1;
	res = NULL;
	rcu_read_lock();
105 106
	for (p = from->next; p != &parent->d_subdirs; p = p->next) {
		struct dentry *d = list_entry(p, struct dentry, d_child);
Al Viro's avatar
Al Viro committed
107 108 109
		if (!simple_positive(d)) {
			skipped = true;
		} else if (!--i) {
110 111 112 113
			res = d;
			break;
		}
	}
Al Viro's avatar
Al Viro committed
114 115 116 117 118 119
	rcu_read_unlock();
	if (skipped) {
		smp_rmb();
		if (unlikely(*seq != n))
			goto retry;
	}
120 121 122 123 124 125
	return res;
}

static void move_cursor(struct dentry *cursor, struct list_head *after)
{
	struct dentry *parent = cursor->d_parent;
Al Viro's avatar
Al Viro committed
126
	unsigned n, *seq = &parent->d_inode->i_dir_seq;
127
	spin_lock(&parent->d_lock);
Al Viro's avatar
Al Viro committed
128 129 130 131 132 133
	for (;;) {
		n = *seq;
		if (!(n & 1) && cmpxchg(seq, n, n + 1) == n)
			break;
		cpu_relax();
	}
134 135 136 137 138
	__list_del(cursor->d_child.prev, cursor->d_child.next);
	if (after)
		list_add(&cursor->d_child, after);
	else
		list_add_tail(&cursor->d_child, &parent->d_subdirs);
Al Viro's avatar
Al Viro committed
139
	smp_store_release(seq, n + 2);
140 141 142
	spin_unlock(&parent->d_lock);
}

143
loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
Linus Torvalds's avatar
Linus Torvalds committed
144
{
Nick Piggin's avatar
Nick Piggin committed
145
	struct dentry *dentry = file->f_path.dentry;
146
	switch (whence) {
Linus Torvalds's avatar
Linus Torvalds committed
147 148 149 150 151 152 153 154 155 156 157 158
		case 1:
			offset += file->f_pos;
		case 0:
			if (offset >= 0)
				break;
		default:
			return -EINVAL;
	}
	if (offset != file->f_pos) {
		file->f_pos = offset;
		if (file->f_pos >= 2) {
			struct dentry *cursor = file->private_data;
159
			struct dentry *to;
Linus Torvalds's avatar
Linus Torvalds committed
160 161
			loff_t n = file->f_pos - 2;

162
			inode_lock_shared(dentry->d_inode);
163 164
			to = next_positive(dentry, &dentry->d_subdirs, n);
			move_cursor(cursor, to ? &to->d_child : NULL);
165
			inode_unlock_shared(dentry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169
		}
	}
	return offset;
}
170
EXPORT_SYMBOL(dcache_dir_lseek);
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174 175 176 177 178 179 180 181 182 183

/* Relationship between i_mode and the DT_xxx types */
static inline unsigned char dt_type(struct inode *inode)
{
	return (inode->i_mode >> 12) & 15;
}

/*
 * Directory is locked and all positive dentries in it are safe, since
 * for ramfs-type trees they can't go away without unlink() or rmdir(),
 * both impossible due to the lock on directory.
 */

184
int dcache_readdir(struct file *file, struct dir_context *ctx)
Linus Torvalds's avatar
Linus Torvalds committed
185
{
186 187
	struct dentry *dentry = file->f_path.dentry;
	struct dentry *cursor = file->private_data;
188 189 190
	struct list_head *p = &cursor->d_child;
	struct dentry *next;
	bool moved = false;
Linus Torvalds's avatar
Linus Torvalds committed
191

192 193 194
	if (!dir_emit_dots(file, ctx))
		return 0;

195 196 197
	if (ctx->pos == 2)
		p = &dentry->d_subdirs;
	while ((next = next_positive(dentry, p, 1)) != NULL) {
198
		if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
199
			      d_inode(next)->i_ino, dt_type(d_inode(next))))
200 201 202
			break;
		moved = true;
		p = &next->d_child;
203
		ctx->pos++;
Linus Torvalds's avatar
Linus Torvalds committed
204
	}
205 206
	if (moved)
		move_cursor(cursor, p);
Linus Torvalds's avatar
Linus Torvalds committed
207 208
	return 0;
}
209
EXPORT_SYMBOL(dcache_readdir);
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213 214

ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
{
	return -EISDIR;
}
215
EXPORT_SYMBOL(generic_read_dir);
Linus Torvalds's avatar
Linus Torvalds committed
216

217
const struct file_operations simple_dir_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
218 219 220 221
	.open		= dcache_dir_open,
	.release	= dcache_dir_close,
	.llseek		= dcache_dir_lseek,
	.read		= generic_read_dir,
222
	.iterate_shared	= dcache_readdir,
223
	.fsync		= noop_fsync,
Linus Torvalds's avatar
Linus Torvalds committed
224
};
225
EXPORT_SYMBOL(simple_dir_operations);
Linus Torvalds's avatar
Linus Torvalds committed
226

227
const struct inode_operations simple_dir_inode_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
228 229
	.lookup		= simple_lookup,
};
230
EXPORT_SYMBOL(simple_dir_inode_operations);
Linus Torvalds's avatar
Linus Torvalds committed
231

232 233 234 235
static const struct super_operations simple_super_operations = {
	.statfs		= simple_statfs,
};

Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239
/*
 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
 * will never be mountable)
 */
240 241
struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name,
	const struct super_operations *ops, const struct xattr_handler **xattr,
242
	const struct dentry_operations *dops, unsigned long magic)
Linus Torvalds's avatar
Linus Torvalds committed
243
{
244
	struct super_block *s;
Linus Torvalds's avatar
Linus Torvalds committed
245 246
	struct dentry *dentry;
	struct inode *root;
247
	struct qstr d_name = QSTR_INIT(name, strlen(name));
Linus Torvalds's avatar
Linus Torvalds committed
248

249
	s = sget_userns(fs_type, NULL, set_anon_super, SB_KERNMOUNT|SB_NOUSER,
250
			&init_user_ns, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
251
	if (IS_ERR(s))
Al Viro's avatar
Al Viro committed
252
		return ERR_CAST(s);
Linus Torvalds's avatar
Linus Torvalds committed
253

254
	s->s_maxbytes = MAX_LFS_FILESIZE;
255 256
	s->s_blocksize = PAGE_SIZE;
	s->s_blocksize_bits = PAGE_SHIFT;
Linus Torvalds's avatar
Linus Torvalds committed
257
	s->s_magic = magic;
258
	s->s_op = ops ? ops : &simple_super_operations;
259
	s->s_xattr = xattr;
Linus Torvalds's avatar
Linus Torvalds committed
260 261 262 263
	s->s_time_gran = 1;
	root = new_inode(s);
	if (!root)
		goto Enomem;
264 265 266 267 268 269
	/*
	 * since this is the first inode, make it number 1. New inodes created
	 * after this must take care not to collide with it (by passing
	 * max_reserved of 1 to iunique).
	 */
	root->i_ino = 1;
Linus Torvalds's avatar
Linus Torvalds committed
270
	root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
271
	root->i_atime = root->i_mtime = root->i_ctime = current_time(root);
272
	dentry = __d_alloc(s, &d_name);
Linus Torvalds's avatar
Linus Torvalds committed
273 274 275 276 277 278
	if (!dentry) {
		iput(root);
		goto Enomem;
	}
	d_instantiate(dentry, root);
	s->s_root = dentry;
279
	s->s_d_op = dops;
280
	s->s_flags |= SB_ACTIVE;
Al Viro's avatar
Al Viro committed
281
	return dget(s->s_root);
Linus Torvalds's avatar
Linus Torvalds committed
282 283

Enomem:
284
	deactivate_locked_super(s);
Al Viro's avatar
Al Viro committed
285
	return ERR_PTR(-ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
286
}
287
EXPORT_SYMBOL(mount_pseudo_xattr);
Linus Torvalds's avatar
Linus Torvalds committed
288

Stephen Boyd's avatar
Stephen Boyd committed
289 290 291 292 293 294
int simple_open(struct inode *inode, struct file *file)
{
	if (inode->i_private)
		file->private_data = inode->i_private;
	return 0;
}
295
EXPORT_SYMBOL(simple_open);
Stephen Boyd's avatar
Stephen Boyd committed
296

Linus Torvalds's avatar
Linus Torvalds committed
297 298
int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
{
299
	struct inode *inode = d_inode(old_dentry);
Linus Torvalds's avatar
Linus Torvalds committed
300

301
	inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
302
	inc_nlink(inode);
Al Viro's avatar
Al Viro committed
303
	ihold(inode);
Linus Torvalds's avatar
Linus Torvalds committed
304 305 306 307
	dget(dentry);
	d_instantiate(dentry, inode);
	return 0;
}
308
EXPORT_SYMBOL(simple_link);
Linus Torvalds's avatar
Linus Torvalds committed
309 310 311 312 313 314

int simple_empty(struct dentry *dentry)
{
	struct dentry *child;
	int ret = 0;

Nick Piggin's avatar
Nick Piggin committed
315
	spin_lock(&dentry->d_lock);
316
	list_for_each_entry(child, &dentry->d_subdirs, d_child) {
317 318 319
		spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
		if (simple_positive(child)) {
			spin_unlock(&child->d_lock);
Linus Torvalds's avatar
Linus Torvalds committed
320
			goto out;
321 322 323
		}
		spin_unlock(&child->d_lock);
	}
Linus Torvalds's avatar
Linus Torvalds committed
324 325
	ret = 1;
out:
Nick Piggin's avatar
Nick Piggin committed
326
	spin_unlock(&dentry->d_lock);
Linus Torvalds's avatar
Linus Torvalds committed
327 328
	return ret;
}
329
EXPORT_SYMBOL(simple_empty);
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332

int simple_unlink(struct inode *dir, struct dentry *dentry)
{
333
	struct inode *inode = d_inode(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
334

335
	inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
336
	drop_nlink(inode);
Linus Torvalds's avatar
Linus Torvalds committed
337 338 339
	dput(dentry);
	return 0;
}
340
EXPORT_SYMBOL(simple_unlink);
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344 345 346

int simple_rmdir(struct inode *dir, struct dentry *dentry)
{
	if (!simple_empty(dentry))
		return -ENOTEMPTY;

347
	drop_nlink(d_inode(dentry));
Linus Torvalds's avatar
Linus Torvalds committed
348
	simple_unlink(dir, dentry);
349
	drop_nlink(dir);
Linus Torvalds's avatar
Linus Torvalds committed
350 351
	return 0;
}
352
EXPORT_SYMBOL(simple_rmdir);
Linus Torvalds's avatar
Linus Torvalds committed
353 354

int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
355 356
		  struct inode *new_dir, struct dentry *new_dentry,
		  unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
357
{
358
	struct inode *inode = d_inode(old_dentry);
359
	int they_are_dirs = d_is_dir(old_dentry);
Linus Torvalds's avatar
Linus Torvalds committed
360

361 362 363
	if (flags & ~RENAME_NOREPLACE)
		return -EINVAL;

Linus Torvalds's avatar
Linus Torvalds committed
364 365 366
	if (!simple_empty(new_dentry))
		return -ENOTEMPTY;

367
	if (d_really_is_positive(new_dentry)) {
Linus Torvalds's avatar
Linus Torvalds committed
368
		simple_unlink(new_dir, new_dentry);
369
		if (they_are_dirs) {
370
			drop_nlink(d_inode(new_dentry));
371
			drop_nlink(old_dir);
372
		}
Linus Torvalds's avatar
Linus Torvalds committed
373
	} else if (they_are_dirs) {
374
		drop_nlink(old_dir);
375
		inc_nlink(new_dir);
Linus Torvalds's avatar
Linus Torvalds committed
376 377 378
	}

	old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
379
		new_dir->i_mtime = inode->i_ctime = current_time(old_dir);
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382

	return 0;
}
383
EXPORT_SYMBOL(simple_rename);
Linus Torvalds's avatar
Linus Torvalds committed
384

385
/**
386
 * simple_setattr - setattr for simple filesystem
387 388 389 390 391
 * @dentry: dentry
 * @iattr: iattr structure
 *
 * Returns 0 on success, -error on failure.
 *
392 393 394 395 396 397
 * simple_setattr is a simple ->setattr implementation without a proper
 * implementation of size changes.
 *
 * It can either be used for in-memory filesystems or special files
 * on simple regular filesystems.  Anything that needs to change on-disk
 * or wire state on size changes needs its own setattr method.
398 399 400
 */
int simple_setattr(struct dentry *dentry, struct iattr *iattr)
{
401
	struct inode *inode = d_inode(dentry);
402 403
	int error;

404
	error = setattr_prepare(dentry, iattr);
405 406 407
	if (error)
		return error;

408 409
	if (iattr->ia_valid & ATTR_SIZE)
		truncate_setsize(inode, iattr->ia_size);
410
	setattr_copy(inode, iattr);
411 412
	mark_inode_dirty(inode);
	return 0;
413 414 415
}
EXPORT_SYMBOL(simple_setattr);

Linus Torvalds's avatar
Linus Torvalds committed
416 417
int simple_readpage(struct file *file, struct page *page)
{
418
	clear_highpage(page);
Linus Torvalds's avatar
Linus Torvalds committed
419 420 421 422 423
	flush_dcache_page(page);
	SetPageUptodate(page);
	unlock_page(page);
	return 0;
}
424
EXPORT_SYMBOL(simple_readpage);
Linus Torvalds's avatar
Linus Torvalds committed
425

426 427 428 429 430 431 432
int simple_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
{
	struct page *page;
	pgoff_t index;

433
	index = pos >> PAGE_SHIFT;
434

435
	page = grab_cache_page_write_begin(mapping, index, flags);
436 437 438 439 440
	if (!page)
		return -ENOMEM;

	*pagep = page;

441 442
	if (!PageUptodate(page) && (len != PAGE_SIZE)) {
		unsigned from = pos & (PAGE_SIZE - 1);
443

444
		zero_user_segments(page, 0, from, from + len, PAGE_SIZE);
445 446
	}
	return 0;
447
}
448
EXPORT_SYMBOL(simple_write_begin);
449

450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
/**
 * simple_write_end - .write_end helper for non-block-device FSes
 * @available: See .write_end of address_space_operations
 * @file: 		"
 * @mapping: 		"
 * @pos: 		"
 * @len: 		"
 * @copied: 		"
 * @page: 		"
 * @fsdata: 		"
 *
 * simple_write_end does the minimum needed for updating a page after writing is
 * done. It has the same API signature as the .write_end of
 * address_space_operations vector. So it can just be set onto .write_end for
 * FSes that don't need any other processing. i_mutex is assumed to be held.
 * Block based filesystems should use generic_write_end().
 * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
 * is not called, so a filesystem that actually does store data in .write_inode
 * should extend on what's done here with a call to mark_inode_dirty() in the
 * case that i_size has changed.
470 471
 *
 * Use *ONLY* with simple_readpage()
472
 */
473 474 475 476
int simple_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *page, void *fsdata)
{
477 478
	struct inode *inode = page->mapping->host;
	loff_t last_pos = pos + copied;
479 480

	/* zero the stale part of the page if we did a short copy */
481 482 483
	if (!PageUptodate(page)) {
		if (copied < len) {
			unsigned from = pos & (PAGE_SIZE - 1);
484

485 486
			zero_user(page, from + copied, len - copied);
		}
487
		SetPageUptodate(page);
488
	}
489 490 491 492 493 494
	/*
	 * No need to use i_size_read() here, the i_size
	 * cannot change under us because we hold the i_mutex.
	 */
	if (last_pos > inode->i_size)
		i_size_write(inode, last_pos);
495

496
	set_page_dirty(page);
497
	unlock_page(page);
498
	put_page(page);
499 500 501

	return copied;
}
502
EXPORT_SYMBOL(simple_write_end);
503

504 505 506 507 508
/*
 * the inodes created here are not hashed. If you use iunique to generate
 * unique inode values later for this filesystem, then you must take care
 * to pass it an appropriate max_reserved value to avoid collisions.
 */
509
int simple_fill_super(struct super_block *s, unsigned long magic,
510
		      const struct tree_descr *files)
Linus Torvalds's avatar
Linus Torvalds committed
511 512 513 514 515 516
{
	struct inode *inode;
	struct dentry *root;
	struct dentry *dentry;
	int i;

517 518
	s->s_blocksize = PAGE_SIZE;
	s->s_blocksize_bits = PAGE_SHIFT;
Linus Torvalds's avatar
Linus Torvalds committed
519
	s->s_magic = magic;
520
	s->s_op = &simple_super_operations;
Linus Torvalds's avatar
Linus Torvalds committed
521 522 523 524 525
	s->s_time_gran = 1;

	inode = new_inode(s);
	if (!inode)
		return -ENOMEM;
526 527 528 529 530
	/*
	 * because the root inode is 1, the files array must not contain an
	 * entry at index 1
	 */
	inode->i_ino = 1;
Linus Torvalds's avatar
Linus Torvalds committed
531
	inode->i_mode = S_IFDIR | 0755;
532
	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
Linus Torvalds's avatar
Linus Torvalds committed
533 534
	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;
535
	set_nlink(inode, 2);
536 537
	root = d_make_root(inode);
	if (!root)
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541
		return -ENOMEM;
	for (i = 0; !files->name || files->name[0]; i++, files++) {
		if (!files->name)
			continue;
542 543 544 545 546 547 548

		/* warn if it tries to conflict with the root inode */
		if (unlikely(i == 1))
			printk(KERN_WARNING "%s: %s passed in a files array"
				"with an index of 1!\n", __func__,
				s->s_type->name);

Linus Torvalds's avatar
Linus Torvalds committed
549 550 551 552
		dentry = d_alloc_name(root, files->name);
		if (!dentry)
			goto out;
		inode = new_inode(s);
553 554
		if (!inode) {
			dput(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
555
			goto out;
556
		}
Linus Torvalds's avatar
Linus Torvalds committed
557
		inode->i_mode = S_IFREG | files->mode;
558
		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
Linus Torvalds's avatar
Linus Torvalds committed
559 560 561 562 563 564 565 566
		inode->i_fop = files->ops;
		inode->i_ino = i;
		d_add(dentry, inode);
	}
	s->s_root = root;
	return 0;
out:
	d_genocide(root);
567
	shrink_dcache_parent(root);
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570
	dput(root);
	return -ENOMEM;
}
571
EXPORT_SYMBOL(simple_fill_super);
Linus Torvalds's avatar
Linus Torvalds committed
572 573 574

static DEFINE_SPINLOCK(pin_fs_lock);

575
int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579 580
{
	struct vfsmount *mnt = NULL;
	spin_lock(&pin_fs_lock);
	if (unlikely(!*mount)) {
		spin_unlock(&pin_fs_lock);
581
		mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584 585 586 587 588 589 590 591 592 593
		if (IS_ERR(mnt))
			return PTR_ERR(mnt);
		spin_lock(&pin_fs_lock);
		if (!*mount)
			*mount = mnt;
	}
	mntget(*mount);
	++*count;
	spin_unlock(&pin_fs_lock);
	mntput(mnt);
	return 0;
}
594
EXPORT_SYMBOL(simple_pin_fs);
Linus Torvalds's avatar
Linus Torvalds committed
595 596 597 598 599 600 601 602 603 604 605

void simple_release_fs(struct vfsmount **mount, int *count)
{
	struct vfsmount *mnt;
	spin_lock(&pin_fs_lock);
	mnt = *mount;
	if (!--*count)
		*mount = NULL;
	spin_unlock(&pin_fs_lock);
	mntput(mnt);
}
606
EXPORT_SYMBOL(simple_release_fs);
Linus Torvalds's avatar
Linus Torvalds committed
607

608 609 610 611 612 613 614 615 616 617 618 619 620 621
/**
 * simple_read_from_buffer - copy data from the buffer to user space
 * @to: the user space buffer to read to
 * @count: the maximum number of bytes to read
 * @ppos: the current position in the buffer
 * @from: the buffer to read from
 * @available: the size of the buffer
 *
 * The simple_read_from_buffer() function reads up to @count bytes from the
 * buffer @from at offset @ppos into the user space address starting at @to.
 *
 * On success, the number of bytes read is returned and the offset @ppos is
 * advanced by this number, or negative value is returned on error.
 **/
Linus Torvalds's avatar
Linus Torvalds committed
622 623 624 625
ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
				const void *from, size_t available)
{
	loff_t pos = *ppos;
626 627
	size_t ret;

Linus Torvalds's avatar
Linus Torvalds committed
628 629
	if (pos < 0)
		return -EINVAL;
630
	if (pos >= available || !count)
Linus Torvalds's avatar
Linus Torvalds committed
631 632 633
		return 0;
	if (count > available - pos)
		count = available - pos;
634 635
	ret = copy_to_user(to, from + pos, count);
	if (ret == count)
Linus Torvalds's avatar
Linus Torvalds committed
636
		return -EFAULT;
637
	count -= ret;
Linus Torvalds's avatar
Linus Torvalds committed
638 639 640
	*ppos = pos + count;
	return count;
}
641
EXPORT_SYMBOL(simple_read_from_buffer);
Linus Torvalds's avatar
Linus Torvalds committed
642

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
/**
 * simple_write_to_buffer - copy data from user space to the buffer
 * @to: the buffer to write to
 * @available: the size of the buffer
 * @ppos: the current position in the buffer
 * @from: the user space buffer to read from
 * @count: the maximum number of bytes to read
 *
 * The simple_write_to_buffer() function reads up to @count bytes from the user
 * space address starting at @from into the buffer @to at offset @ppos.
 *
 * On success, the number of bytes written is returned and the offset @ppos is
 * advanced by this number, or negative value is returned on error.
 **/
ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
		const void __user *from, size_t count)
{
	loff_t pos = *ppos;
	size_t res;

	if (pos < 0)
		return -EINVAL;
	if (pos >= available || !count)
		return 0;
	if (count > available - pos)
		count = available - pos;
	res = copy_from_user(to + pos, from, count);
	if (res == count)
		return -EFAULT;
	count -= res;
	*ppos = pos + count;
	return count;
}
676
EXPORT_SYMBOL(simple_write_to_buffer);
677

678 679 680 681 682 683 684 685 686 687 688 689 690 691
/**
 * memory_read_from_buffer - copy data from the buffer
 * @to: the kernel space buffer to read to
 * @count: the maximum number of bytes to read
 * @ppos: the current position in the buffer
 * @from: the buffer to read from
 * @available: the size of the buffer
 *
 * The memory_read_from_buffer() function reads up to @count bytes from the
 * buffer @from at offset @ppos into the kernel space address starting at @to.
 *
 * On success, the number of bytes read is returned and the offset @ppos is
 * advanced by this number, or negative value is returned on error.
 **/
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
				const void *from, size_t available)
{
	loff_t pos = *ppos;

	if (pos < 0)
		return -EINVAL;
	if (pos >= available)
		return 0;
	if (count > available - pos)
		count = available - pos;
	memcpy(to, from + pos, count);
	*ppos = pos + count;

	return count;
}
708
EXPORT_SYMBOL(memory_read_from_buffer);
709

Linus Torvalds's avatar
Linus Torvalds committed
710 711 712 713 714 715
/*
 * Transaction based IO.
 * The file expects a single write which triggers the transaction, and then
 * possibly a read which collects the result - which is stored in a
 * file-local buffer.
 */
716 717 718 719 720 721 722 723 724 725 726 727 728 729

void simple_transaction_set(struct file *file, size_t n)
{
	struct simple_transaction_argresp *ar = file->private_data;

	BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);

	/*
	 * The barrier ensures that ar->size will really remain zero until
	 * ar->data is ready for reading.
	 */
	smp_mb();
	ar->size = n;
}
730
EXPORT_SYMBOL(simple_transaction_set);
731

Linus Torvalds's avatar
Linus Torvalds committed
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
{
	struct simple_transaction_argresp *ar;
	static DEFINE_SPINLOCK(simple_transaction_lock);

	if (size > SIMPLE_TRANSACTION_LIMIT - 1)
		return ERR_PTR(-EFBIG);

	ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
	if (!ar)
		return ERR_PTR(-ENOMEM);

	spin_lock(&simple_transaction_lock);

	/* only one write allowed per open */
	if (file->private_data) {
		spin_unlock(&simple_transaction_lock);
		free_page((unsigned long)ar);
		return ERR_PTR(-EBUSY);
	}

	file->private_data = ar;

	spin_unlock(&simple_transaction_lock);

	if (copy_from_user(ar->data, buf, size))
		return ERR_PTR(-EFAULT);

	return ar->data;
}
762
EXPORT_SYMBOL(simple_transaction_get);
Linus Torvalds's avatar
Linus Torvalds committed
763 764 765 766 767 768 769 770 771

ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
{
	struct simple_transaction_argresp *ar = file->private_data;

	if (!ar)
		return 0;
	return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
}
772
EXPORT_SYMBOL(simple_transaction_read);
Linus Torvalds's avatar
Linus Torvalds committed
773 774 775 776 777 778

int simple_transaction_release(struct inode *inode, struct file *file)
{
	free_page((unsigned long)file->private_data);
	return 0;
}
779
EXPORT_SYMBOL(simple_transaction_release);
Linus Torvalds's avatar
Linus Torvalds committed
780

781 782 783
/* Simple attribute files */

struct simple_attr {
784 785
	int (*get)(void *, u64 *);
	int (*set)(void *, u64);
786 787 788 789
	char get_buf[24];	/* enough to store a u64 and "\n\0" */
	char set_buf[24];
	void *data;
	const char *fmt;	/* format for read operation */
790
	struct mutex mutex;	/* protects access to these buffers */
791 792 793 794 795
};

/* simple_attr_open is called by an actual attribute open file operation
 * to set the attribute specific access operations. */
int simple_attr_open(struct inode *inode, struct file *file,
796
		     int (*get)(void *, u64 *), int (*set)(void *, u64),
797 798 799 800 801 802 803 804 805 806
		     const char *fmt)
{
	struct simple_attr *attr;

	attr = kmalloc(sizeof(*attr), GFP_KERNEL);
	if (!attr)
		return -ENOMEM;

	attr->get = get;
	attr->set = set;
807
	attr->data = inode->i_private;
808
	attr->fmt = fmt;
809
	mutex_init(&attr->mutex);
810 811 812 813 814

	file->private_data = attr;

	return nonseekable_open(inode, file);
}
815
EXPORT_SYMBOL_GPL(simple_attr_open);
816

817
int simple_attr_release(struct inode *inode, struct file *file)
818 819 820 821
{
	kfree(file->private_data);
	return 0;
}
822
EXPORT_SYMBOL_GPL(simple_attr_release);	/* GPL-only?  This?  Really? */
823 824 825 826 827 828 829 830 831 832 833 834 835 836

/* read from the buffer that is filled with the get function */
ssize_t simple_attr_read(struct file *file, char __user *buf,
			 size_t len, loff_t *ppos)
{
	struct simple_attr *attr;
	size_t size;
	ssize_t ret;

	attr = file->private_data;

	if (!attr->get)
		return -EACCES;

837 838 839 840
	ret = mutex_lock_interruptible(&attr->mutex);
	if (ret)
		return ret;

841
	if (*ppos) {		/* continued read */
842
		size = strlen(attr->get_buf);
843 844 845 846 847 848
	} else {		/* first read */
		u64 val;
		ret = attr->get(attr->data, &val);
		if (ret)
			goto out;

849
		size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
850 851
				 attr->fmt, (unsigned long long)val);
	}
852 853

	ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
854
out:
855
	mutex_unlock(&attr->mutex);
856 857
	return ret;
}
858
EXPORT_SYMBOL_GPL(simple_attr_read);
859 860 861 862 863 864 865 866 867 868 869 870 871 872

/* interpret the buffer as a number to call the set function with */
ssize_t simple_attr_write(struct file *file, const char __user *buf,
			  size_t len, loff_t *ppos)
{
	struct simple_attr *attr;
	u64 val;
	size_t size;
	ssize_t ret;

	attr = file->private_data;
	if (!attr->set)
		return -EACCES;

873 874 875 876
	ret = mutex_lock_interruptible(&attr->mutex);
	if (ret)
		return ret;

877 878 879 880 881 882
	ret = -EFAULT;
	size = min(sizeof(attr->set_buf) - 1, len);
	if (copy_from_user(attr->set_buf, buf, size))
		goto out;

	attr->set_buf[size] = '\0';
883
	val = simple_strtoll(attr->set_buf, NULL, 0);
884 885 886
	ret = attr->set(attr->data, val);
	if (ret == 0)
		ret = len; /* on success, claim we got the whole input */
887
out:
888
	mutex_unlock(&attr->mutex);
889 890
	return ret;
}
891
EXPORT_SYMBOL_GPL(simple_attr_write);
892

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
/**
 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
 * @sb:		filesystem to do the file handle conversion on
 * @fid:	file handle to convert
 * @fh_len:	length of the file handle in bytes
 * @fh_type:	type of file handle
 * @get_inode:	filesystem callback to retrieve inode
 *
 * This function decodes @fid as long as it has one of the well-known
 * Linux filehandle types and calls @get_inode on it to retrieve the
 * inode for the object specified in the file handle.
 */
struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
		int fh_len, int fh_type, struct inode *(*get_inode)
			(struct super_block *sb, u64 ino, u32 gen))
{
	struct inode *inode = NULL;

	if (fh_len < 2)
		return NULL;

	switch (fh_type) {
	case FILEID_INO32_GEN:
	case FILEID_INO32_GEN_PARENT:
		inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
		break;
	}

921
	return d_obtain_alias(inode);
922 923 924 925
}
EXPORT_SYMBOL_GPL(generic_fh_to_dentry);

/**
926
 * generic_fh_to_parent - generic helper for the fh_to_parent export operation
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
 * @sb:		filesystem to do the file handle conversion on
 * @fid:	file handle to convert
 * @fh_len:	length of the file handle in bytes
 * @fh_type:	type of file handle
 * @get_inode:	filesystem callback to retrieve inode
 *
 * This function decodes @fid as long as it has one of the well-known
 * Linux filehandle types and calls @get_inode on it to retrieve the
 * inode for the _parent_ object specified in the file handle if it
 * is specified in the file handle, or NULL otherwise.
 */
struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
		int fh_len, int fh_type, struct inode *(*get_inode)
			(struct super_block *sb, u64 ino, u32 gen))
{
	struct inode *inode = NULL;

	if (fh_len <= 2)
		return NULL;

	switch (fh_type) {
	case FILEID_INO32_GEN_PARENT:
		inode = get_inode(sb, fid->i32.parent_ino,
				  (fh_len > 3 ? fid->i32.parent_gen : 0));
		break;
	}

954
	return d_obtain_alias(inode);
955 956 957
}
EXPORT_SYMBOL_GPL(generic_fh_to_parent);

958
/**
959 960
 * __generic_file_fsync - generic fsync implementation for simple filesystems
 *
961
 * @file:	file to synchronize
962 963
 * @start:	start offset in bytes
 * @end:	end offset in bytes (inclusive)
964 965 966 967 968 969
 * @datasync:	only synchronize essential metadata if true
 *
 * This is a generic implementation of the fsync method for simple
 * filesystems which track all non-inode metadata in the buffers list
 * hanging off the address_space structure.
 */
970 971
int __generic_file_fsync(struct file *file, loff_t start, loff_t end,
				 int datasync)
Al Viro's avatar
Al Viro committed
972
{
973
	struct inode *inode = file->f_mapping->host;
Al Viro's avatar
Al Viro committed
974 975 976
	int err;
	int ret;

977
	err = file_write_and_wait_range(file, start, end);
978 979 980
	if (err)
		return err;

Al Viro's avatar
Al Viro committed
981
	inode_lock(inode);
Al Viro's avatar
Al Viro committed
982
	ret = sync_mapping_buffers(inode->i_mapping);
983
	if (!(inode->i_state & I_DIRTY_ALL))
984
		goto out;
Al Viro's avatar
Al Viro committed
985
	if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
986
		goto out;
Al Viro's avatar
Al Viro committed
987

988
	err = sync_inode_metadata(inode, 1);
Al Viro's avatar
Al Viro committed
989 990
	if (ret == 0)
		ret = err;
991

992
out:
Al Viro's avatar
Al Viro committed
993
	inode_unlock(inode);
994 995 996 997 998
	/* check and advance again to catch errors after syncing out buffers */
	err = file_check_and_advance_wb_err(file);
	if (ret == 0)
		ret = err;
	return ret;
Al Viro's avatar
Al Viro committed
999
}
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
EXPORT_SYMBOL(__generic_file_fsync);

/**
 * generic_file_fsync - generic fsync implementation for simple filesystems
 *			with flush
 * @file:	file to synchronize
 * @start:	start offset in bytes
 * @end:	end offset in bytes (inclusive)
 * @datasync:	only synchronize essential metadata if true
 *
 */

int generic_file_fsync(struct file *file, loff_t start, loff_t end,
		       int datasync)
{
	struct inode *inode = file->f_mapping->host;
	int err;

	err = __generic_file_fsync(file, start, end, datasync);
	if (err)
		return err;
	return blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
}
1023 1024
EXPORT_SYMBOL(generic_file_fsync);

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
/**
 * generic_check_addressable - Check addressability of file system
 * @blocksize_bits:	log of file system block size
 * @num_blocks:		number of blocks in file system
 *
 * Determine whether a file system with @num_blocks blocks (and a
 * block size of 2**@blocksize_bits) is addressable by the sector_t
 * and page cache of the system.  Return 0 if so and -EFBIG otherwise.
 */
int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)
{
	u64 last_fs_block = num_blocks - 1;
1037
	u64 last_fs_page =
1038
		last_fs_block >> (PAGE_SHIFT - blocksize_bits);
1039 1040 1041 1042

	if (unlikely(num_blocks == 0))
		return 0;

1043
	if ((blocksize_bits < 9) || (blocksize_bits > PAGE_SHIFT))
1044 1045
		return -EINVAL;

1046 1047
	if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) ||
	    (last_fs_page > (pgoff_t)(~0ULL))) {
1048 1049 1050 1051 1052 1053
		return -EFBIG;
	}
	return 0;
}
EXPORT_SYMBOL(generic_check_addressable);

1054 1055 1056
/*
 * No-op implementation of ->fsync for in-memory filesystems.
 */
1057
int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1058 1059 1060 1061
{
	return 0;
}
EXPORT_SYMBOL(noop_fsync);
Al Viro's avatar
Al Viro committed
1062

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
int noop_set_page_dirty(struct page *page)
{
	/*
	 * Unlike __set_page_dirty_no_writeback that handles dirty page
	 * tracking in the page object, dax does all dirty tracking in
	 * the inode address_space in response to mkwrite faults. In the
	 * dax case we only need to worry about potentially dirty CPU
	 * caches, not dirty page cache pages to write back.
	 *
	 * This callback is defined to prevent fallback to
	 * __set_page_dirty_buffers() in set_page_dirty().
	 */
	return 0;
}
EXPORT_SYMBOL_GPL(noop_set_page_dirty);

void noop_invalidatepage(struct page *page, unsigned int offset,
		unsigned int length)
{
	/*
	 * There is no page cache to invalidate in the dax case, however
	 * we need this callback defined to prevent falling back to
	 * block_invalidatepage() in do_invalidatepage().
	 */
}
EXPORT_SYMBOL_GPL(noop_invalidatepage);

ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
{
	/*
	 * iomap based filesystems support direct I/O without need for
	 * this callback. However, it still needs to be set in
	 * inode->a_ops so that open/fcntl know that direct I/O is
	 * generally supported.
	 */
	return -EINVAL;
}
EXPORT_SYMBOL_GPL(noop_direct_IO);

1102 1103
/* Because kfree isn't assignment-compatible with void(void*) ;-/ */
void kfree_link(void *p)
Al Viro's avatar
Al Viro committed
1104
{
1105
	kfree(p);
Al Viro's avatar
Al Viro committed
1106
}
1107
EXPORT_SYMBOL(kfree_link);
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146

/*
 * nop .set_page_dirty method so that people can use .page_mkwrite on
 * anon inodes.
 */
static int anon_set_page_dirty(struct page *page)
{
	return 0;
};

/*
 * A single inode exists for all anon_inode files. Contrary to pipes,
 * anon_inode inodes have no associated per-instance data, so we need
 * only allocate one of them.
 */
struct inode *alloc_anon_inode(struct super_block *s)
{
	static const struct address_space_operations anon_aops = {
		.set_page_dirty = anon_set_page_dirty,
	};
	struct inode *inode = new_inode_pseudo(s);

	if (!inode)
		return ERR_PTR(-ENOMEM);

	inode->i_ino = get_next_ino();
	inode->i_mapping->a_ops = &anon_aops;

	/*
	 * Mark the inode dirty from the very beginning,
	 * that way it will never be moved to the dirty
	 * list because mark_inode_dirty() will think
	 * that it already _is_ on the dirty list.
	 */
	inode->i_state = I_DIRTY;
	inode->i_mode = S_IRUSR | S_IWUSR;
	inode->i_uid = current_fsuid();
	inode->i_gid = current_fsgid();
	inode->i_flags |= S_PRIVATE;
1147
	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
1148 1149 1150
	return inode;
}
EXPORT_SYMBOL(alloc_anon_inode);
1151 1152 1153 1154 1155 1156

/**
 * simple_nosetlease - generic helper for prohibiting leases
 * @filp: file pointer
 * @arg: type of lease to obtain
 * @flp: new lease supplied for insertion
1157
 * @priv: private data for lm_setup operation
1158 1159 1160 1161 1162
 *
 * Generic helper for filesystems that do not wish to allow leases to be set.
 * All arguments are ignored and it just returns -EINVAL.
 */
int
1163 1164
simple_nosetlease(struct file *filp, long arg, struct file_lock **flp,
		  void **priv)
1165 1166 1167 1168
{
	return -EINVAL;
}
EXPORT_SYMBOL(simple_nosetlease);
Al Viro's avatar
Al Viro committed
1169

1170
const char *simple_get_link(struct dentry *dentry, struct inode *inode,
1171
			    struct delayed_call *done)
Al Viro's avatar
Al Viro committed
1172
{
1173
	return inode->i_link;
Al Viro's avatar
Al Viro committed
1174
}
1175
EXPORT_SYMBOL(simple_get_link);
Al Viro's avatar
Al Viro committed
1176 1177

const struct inode_operations simple_symlink_inode_operations = {
1178
	.get_link = simple_get_link,
Al Viro's avatar
Al Viro committed
1179 1180
};
EXPORT_SYMBOL(simple_symlink_inode_operations);
1181 1182 1183 1184 1185 1186 1187 1188 1189

/*
 * Operations for a permanently empty directory.
 */
static struct dentry *empty_dir_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
{
	return ERR_PTR(-ENOENT);
}

1190 1191
static int empty_dir_getattr(const struct path *path, struct kstat *stat,
			     u32 request_mask, unsigned int query_flags)
1192
{
1193
	struct inode *inode = d_inode(path->dentry);
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	generic_fillattr(inode, stat);
	return 0;
}

static int empty_dir_setattr(struct dentry *dentry, struct iattr *attr)
{
	return -EPERM;
}

static ssize_t empty_dir_listxattr(struct dentry *dentry, char *list, size_t size)
{
	return -EOPNOTSUPP;
}

static const struct inode_operations empty_dir_inode_operations = {
	.lookup		= empty_dir_lookup,
	.permission	= generic_permission,
	.setattr	= empty_dir_setattr,
	.getattr	= empty_dir_getattr,
	.listxattr	= empty_dir_listxattr,
};

static loff_t empty_dir_llseek(struct file *file, loff_t offset, int whence)
{
	/* An empty directory has two entries . and .. at offsets 0 and 1 */
	return generic_file_llseek_size(file, offset, whence, 2, 2);
}

static int empty_dir_readdir(struct file *file, struct dir_context *ctx)
{
	dir_emit_dots(file, ctx);
	return 0;
}

static const struct file_operations empty_dir_operations = {
	.llseek		= empty_dir_llseek,
	.read		= generic_read_dir,
1231
	.iterate_shared	= empty_dir_readdir,
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
	.fsync		= noop_fsync,
};


void make_empty_dir_inode(struct inode *inode)
{
	set_nlink(inode, 2);
	inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
	inode->i_uid = GLOBAL_ROOT_UID;
	inode->i_gid = GLOBAL_ROOT_GID;
	inode->i_rdev = 0;
1243
	inode->i_size = 0;
1244 1245 1246 1247
	inode->i_blkbits = PAGE_SHIFT;
	inode->i_blocks = 0;

	inode->i_op = &empty_dir_inode_operations;
1248
	inode->i_opflags &= ~IOP_XATTR;
1249 1250 1251 1252 1253 1254 1255 1256
	inode->i_fop = &empty_dir_operations;
}

bool is_empty_dir_inode(struct inode *inode)
{
	return (inode->i_fop == &empty_dir_operations) &&
		(inode->i_op == &empty_dir_inode_operations);
}