inode.c 23.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * hugetlbpage-backed filesystem.  Based on ramfs.
 *
 * William Irwin, 2002
 *
 * Copyright (C) 2002 Linus Torvalds.
 */

#include <linux/module.h>
#include <linux/thread_info.h>
#include <asm/current.h>
#include <linux/sched.h>		/* remove ASAP */
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/file.h>
16
#include <linux/kernel.h>
L
Linus Torvalds 已提交
17 18 19 20 21
#include <linux/writeback.h>
#include <linux/pagemap.h>
#include <linux/highmem.h>
#include <linux/init.h>
#include <linux/string.h>
22
#include <linux/capability.h>
23
#include <linux/ctype.h>
L
Linus Torvalds 已提交
24 25 26
#include <linux/backing-dev.h>
#include <linux/hugetlb.h>
#include <linux/pagevec.h>
27
#include <linux/parser.h>
28
#include <linux/mman.h>
L
Linus Torvalds 已提交
29 30 31 32 33 34 35 36 37 38 39
#include <linux/quotaops.h>
#include <linux/slab.h>
#include <linux/dnotify.h>
#include <linux/statfs.h>
#include <linux/security.h>

#include <asm/uaccess.h>

/* some random number */
#define HUGETLBFS_MAGIC	0x958458f6

40
static const struct super_operations hugetlbfs_ops;
41
static const struct address_space_operations hugetlbfs_aops;
42
const struct file_operations hugetlbfs_file_operations;
43 44
static const struct inode_operations hugetlbfs_dir_inode_operations;
static const struct inode_operations hugetlbfs_inode_operations;
L
Linus Torvalds 已提交
45 46 47

static struct backing_dev_info hugetlbfs_backing_dev_info = {
	.ra_pages	= 0,	/* No readahead */
48
	.capabilities	= BDI_CAP_NO_ACCT_AND_WRITEBACK,
L
Linus Torvalds 已提交
49 50 51 52
};

int sysctl_hugetlb_shm_group;

53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
enum {
	Opt_size, Opt_nr_inodes,
	Opt_mode, Opt_uid, Opt_gid,
	Opt_err,
};

static match_table_t tokens = {
	{Opt_size,	"size=%s"},
	{Opt_nr_inodes,	"nr_inodes=%s"},
	{Opt_mode,	"mode=%o"},
	{Opt_uid,	"uid=%u"},
	{Opt_gid,	"gid=%u"},
	{Opt_err,	NULL},
};

68 69 70 71 72 73 74 75 76 77
static void huge_pagevec_release(struct pagevec *pvec)
{
	int i;

	for (i = 0; i < pagevec_count(pvec); ++i)
		put_page(pvec->pages[i]);

	pagevec_reinit(pvec);
}

L
Linus Torvalds 已提交
78 79
static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
80
	struct inode *inode = file->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
81 82 83
	loff_t len, vma_len;
	int ret;

84
	/*
85 86 87 88 89 90
	 * vma address alignment (but not the pgoff alignment) has
	 * already been checked by prepare_hugepage_range.  If you add
	 * any error returns here, do so after setting VM_HUGETLB, so
	 * is_vm_hugetlb_page tests below unmap_region go the right
	 * way when do_mmap_pgoff unwinds (may be important on powerpc
	 * and ia64).
91 92 93
	 */
	vma->vm_flags |= VM_HUGETLB | VM_RESERVED;
	vma->vm_ops = &hugetlb_vm_ops;
L
Linus Torvalds 已提交
94

95 96 97
	if (vma->vm_pgoff & ~(HPAGE_MASK >> PAGE_SHIFT))
		return -EINVAL;

L
Linus Torvalds 已提交
98 99
	vma_len = (loff_t)(vma->vm_end - vma->vm_start);

100
	mutex_lock(&inode->i_mutex);
L
Linus Torvalds 已提交
101 102 103 104 105
	file_accessed(file);

	ret = -ENOMEM;
	len = vma_len + ((loff_t)vma->vm_pgoff << PAGE_SHIFT);

106 107 108
	if (hugetlb_reserve_pages(inode,
				vma->vm_pgoff >> (HPAGE_SHIFT-PAGE_SHIFT),
				len >> HPAGE_SHIFT, vma))
109
		goto out;
110

A
Adam Litke 已提交
111 112
	ret = 0;
	hugetlb_prefault_arch_hook(vma->vm_mm);
113
	if (vma->vm_flags & VM_WRITE && inode->i_size < len)
L
Linus Torvalds 已提交
114 115
		inode->i_size = len;
out:
116
	mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
117 118 119 120 121

	return ret;
}

/*
122
 * Called under down_write(mmap_sem).
L
Linus Torvalds 已提交
123 124
 */

125
#ifndef HAVE_ARCH_HUGETLB_UNMAPPED_AREA
L
Linus Torvalds 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138
static unsigned long
hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
		unsigned long len, unsigned long pgoff, unsigned long flags)
{
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	unsigned long start_addr;

	if (len & ~HPAGE_MASK)
		return -EINVAL;
	if (len > TASK_SIZE)
		return -ENOMEM;

139
	if (flags & MAP_FIXED) {
140
		if (prepare_hugepage_range(addr, len))
141 142 143 144
			return -EINVAL;
		return addr;
	}

L
Linus Torvalds 已提交
145 146 147 148 149 150 151 152 153 154
	if (addr) {
		addr = ALIGN(addr, HPAGE_SIZE);
		vma = find_vma(mm, addr);
		if (TASK_SIZE - len >= addr &&
		    (!vma || addr + len <= vma->vm_start))
			return addr;
	}

	start_addr = mm->free_area_cache;

155 156 157
	if (len <= mm->cached_hole_size)
		start_addr = TASK_UNMAPPED_BASE;

L
Linus Torvalds 已提交
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
full_search:
	addr = ALIGN(start_addr, HPAGE_SIZE);

	for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
		/* At this point:  (!vma || addr < vma->vm_end). */
		if (TASK_SIZE - len < addr) {
			/*
			 * Start a new search - just in case we missed
			 * some holes.
			 */
			if (start_addr != TASK_UNMAPPED_BASE) {
				start_addr = TASK_UNMAPPED_BASE;
				goto full_search;
			}
			return -ENOMEM;
		}

		if (!vma || addr + len <= vma->vm_start)
			return addr;
		addr = ALIGN(vma->vm_end, HPAGE_SIZE);
	}
}
#endif

B
Badari Pulavarty 已提交
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
static int
hugetlbfs_read_actor(struct page *page, unsigned long offset,
			char __user *buf, unsigned long count,
			unsigned long size)
{
	char *kaddr;
	unsigned long left, copied = 0;
	int i, chunksize;

	if (size > count)
		size = count;

	/* Find which 4k chunk and offset with in that chunk */
	i = offset >> PAGE_CACHE_SHIFT;
	offset = offset & ~PAGE_CACHE_MASK;

	while (size) {
		chunksize = PAGE_CACHE_SIZE;
		if (offset)
			chunksize -= offset;
		if (chunksize > size)
			chunksize = size;
		kaddr = kmap(&page[i]);
		left = __copy_to_user(buf, kaddr + offset, chunksize);
		kunmap(&page[i]);
		if (left) {
			copied += (chunksize - left);
			break;
		}
		offset = 0;
		size -= chunksize;
		buf += chunksize;
		copied += chunksize;
		i++;
	}
	return copied ? copied : -EFAULT;
}

/*
 * Support for read() - Find the page attached to f_mapping and copy out the
 * data. Its *very* similar to do_generic_mapping_read(), we can't use that
 * since it has PAGE_CACHE_SIZE assumptions.
 */
static ssize_t hugetlbfs_read(struct file *filp, char __user *buf,
			      size_t len, loff_t *ppos)
{
	struct address_space *mapping = filp->f_mapping;
	struct inode *inode = mapping->host;
	unsigned long index = *ppos >> HPAGE_SHIFT;
	unsigned long offset = *ppos & ~HPAGE_MASK;
	unsigned long end_index;
	loff_t isize;
	ssize_t retval = 0;

	mutex_lock(&inode->i_mutex);

	/* validate length */
	if (len == 0)
		goto out;

	isize = i_size_read(inode);
	if (!isize)
		goto out;

	end_index = (isize - 1) >> HPAGE_SHIFT;
	for (;;) {
		struct page *page;
		int nr, ret;

		/* nr is the maximum number of bytes to copy from this page */
		nr = HPAGE_SIZE;
		if (index >= end_index) {
			if (index > end_index)
				goto out;
			nr = ((isize - 1) & ~HPAGE_MASK) + 1;
			if (nr <= offset) {
				goto out;
			}
		}
		nr = nr - offset;

		/* Find the page */
		page = find_get_page(mapping, index);
		if (unlikely(page == NULL)) {
			/*
			 * We have a HOLE, zero out the user-buffer for the
			 * length of the hole or request.
			 */
			ret = len < nr ? len : nr;
			if (clear_user(buf, ret))
				ret = -EFAULT;
		} else {
			/*
			 * We have the page, copy it to user space buffer.
			 */
			ret = hugetlbfs_read_actor(page, offset, buf, len, nr);
		}
		if (ret < 0) {
			if (retval == 0)
				retval = ret;
			if (page)
				page_cache_release(page);
			goto out;
		}

		offset += ret;
		retval += ret;
		len -= ret;
		index += offset >> HPAGE_SHIFT;
		offset &= ~HPAGE_MASK;

		if (page)
			page_cache_release(page);

		/* short read or no more work */
		if ((ret != nr) || (len == 0))
			break;
	}
out:
	*ppos = ((loff_t)index << HPAGE_SHIFT) + offset;
	mutex_unlock(&inode->i_mutex);
	return retval;
}

L
Linus Torvalds 已提交
306 307 308 309 310 311 312 313 314 315
/*
 * Read a page. Again trivial. If it didn't already exist
 * in the page cache, it is zero-filled.
 */
static int hugetlbfs_readpage(struct file *file, struct page * page)
{
	unlock_page(page);
	return -EINVAL;
}

N
Nick Piggin 已提交
316 317 318 319
static int hugetlbfs_write_begin(struct file *file,
			struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
L
Linus Torvalds 已提交
320 321 322 323
{
	return -EINVAL;
}

N
Nick Piggin 已提交
324 325 326
static int hugetlbfs_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *page, void *fsdata)
L
Linus Torvalds 已提交
327
{
N
Nick Piggin 已提交
328
	BUG();
L
Linus Torvalds 已提交
329 330 331 332 333
	return -EINVAL;
}

static void truncate_huge_page(struct page *page)
{
334
	cancel_dirty_page(page, /* No IO accounting for huge pages? */0);
L
Linus Torvalds 已提交
335 336 337 338 339
	ClearPageUptodate(page);
	remove_from_page_cache(page);
	put_page(page);
}

340
static void truncate_hugepages(struct inode *inode, loff_t lstart)
L
Linus Torvalds 已提交
341
{
342
	struct address_space *mapping = &inode->i_data;
L
Linus Torvalds 已提交
343 344 345
	const pgoff_t start = lstart >> HPAGE_SHIFT;
	struct pagevec pvec;
	pgoff_t next;
346
	int i, freed = 0;
L
Linus Torvalds 已提交
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366

	pagevec_init(&pvec, 0);
	next = start;
	while (1) {
		if (!pagevec_lookup(&pvec, mapping, next, PAGEVEC_SIZE)) {
			if (next == start)
				break;
			next = start;
			continue;
		}

		for (i = 0; i < pagevec_count(&pvec); ++i) {
			struct page *page = pvec.pages[i];

			lock_page(page);
			if (page->index > next)
				next = page->index;
			++next;
			truncate_huge_page(page);
			unlock_page(page);
367
			freed++;
L
Linus Torvalds 已提交
368 369 370 371
		}
		huge_pagevec_release(&pvec);
	}
	BUG_ON(!lstart && mapping->nrpages);
372
	hugetlb_unreserve_pages(inode, start, freed);
L
Linus Torvalds 已提交
373 374 375 376
}

static void hugetlbfs_delete_inode(struct inode *inode)
{
377
	truncate_hugepages(inode, 0);
378 379 380
	clear_inode(inode);
}

381
static void hugetlbfs_forget_inode(struct inode *inode) __releases(inode_lock)
L
Linus Torvalds 已提交
382
{
383 384 385
	struct super_block *sb = inode->i_sb;

	if (!hlist_unhashed(&inode->i_hash)) {
J
Joern Engel 已提交
386
		if (!(inode->i_state & (I_DIRTY|I_SYNC)))
387 388 389 390 391 392 393
			list_move(&inode->i_list, &inode_unused);
		inodes_stat.nr_unused++;
		if (!sb || (sb->s_flags & MS_ACTIVE)) {
			spin_unlock(&inode_lock);
			return;
		}
		inode->i_state |= I_WILL_FREE;
L
Linus Torvalds 已提交
394
		spin_unlock(&inode_lock);
395 396 397 398 399 400 401 402 403
		/*
		 * write_inode_now is a noop as we set BDI_CAP_NO_WRITEBACK
		 * in our backing_dev_info.
		 */
		write_inode_now(inode, 1);
		spin_lock(&inode_lock);
		inode->i_state &= ~I_WILL_FREE;
		inodes_stat.nr_unused--;
		hlist_del_init(&inode->i_hash);
L
Linus Torvalds 已提交
404 405 406 407 408 409
	}
	list_del_init(&inode->i_list);
	list_del_init(&inode->i_sb_list);
	inode->i_state |= I_FREEING;
	inodes_stat.nr_inodes--;
	spin_unlock(&inode_lock);
410
	truncate_hugepages(inode, 0);
L
Linus Torvalds 已提交
411 412 413 414 415 416 417
	clear_inode(inode);
	destroy_inode(inode);
}

static void hugetlbfs_drop_inode(struct inode *inode)
{
	if (!inode->i_nlink)
418
		generic_delete_inode(inode);
L
Linus Torvalds 已提交
419 420 421 422 423
	else
		hugetlbfs_forget_inode(inode);
}

static inline void
H
Hugh Dickins 已提交
424
hugetlb_vmtruncate_list(struct prio_tree_root *root, pgoff_t pgoff)
L
Linus Torvalds 已提交
425 426 427 428
{
	struct vm_area_struct *vma;
	struct prio_tree_iter iter;

H
Hugh Dickins 已提交
429
	vma_prio_tree_foreach(vma, &iter, root, pgoff, ULONG_MAX) {
L
Linus Torvalds 已提交
430 431 432
		unsigned long v_offset;

		/*
H
Hugh Dickins 已提交
433 434 435 436
		 * Can the expression below overflow on 32-bit arches?
		 * No, because the prio_tree returns us only those vmas
		 * which overlap the truncated area starting at pgoff,
		 * and no vma on a 32-bit arch can span beyond the 4GB.
L
Linus Torvalds 已提交
437
		 */
H
Hugh Dickins 已提交
438 439 440
		if (vma->vm_pgoff < pgoff)
			v_offset = (pgoff - vma->vm_pgoff) << PAGE_SHIFT;
		else
L
Linus Torvalds 已提交
441 442
			v_offset = 0;

443
		__unmap_hugepage_range(vma,
444
				vma->vm_start + v_offset, vma->vm_end);
L
Linus Torvalds 已提交
445 446 447 448 449
	}
}

static int hugetlb_vmtruncate(struct inode *inode, loff_t offset)
{
H
Hugh Dickins 已提交
450
	pgoff_t pgoff;
L
Linus Torvalds 已提交
451 452 453
	struct address_space *mapping = inode->i_mapping;

	BUG_ON(offset & ~HPAGE_MASK);
H
Hugh Dickins 已提交
454
	pgoff = offset >> PAGE_SHIFT;
L
Linus Torvalds 已提交
455

456
	i_size_write(inode, offset);
L
Linus Torvalds 已提交
457 458 459 460
	spin_lock(&mapping->i_mmap_lock);
	if (!prio_tree_empty(&mapping->i_mmap))
		hugetlb_vmtruncate_list(&mapping->i_mmap, pgoff);
	spin_unlock(&mapping->i_mmap_lock);
461
	truncate_hugepages(inode, offset);
L
Linus Torvalds 已提交
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
	return 0;
}

static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int error;
	unsigned int ia_valid = attr->ia_valid;

	BUG_ON(!inode);

	error = inode_change_ok(inode, attr);
	if (error)
		goto out;

	if (ia_valid & ATTR_SIZE) {
		error = -EINVAL;
		if (!(attr->ia_size & ~HPAGE_MASK))
			error = hugetlb_vmtruncate(inode, attr->ia_size);
		if (error)
			goto out;
		attr->ia_valid &= ~ATTR_SIZE;
	}
	error = inode_setattr(inode, attr);
out:
	return error;
}

static struct inode *hugetlbfs_get_inode(struct super_block *sb, uid_t uid, 
					gid_t gid, int mode, dev_t dev)
{
	struct inode *inode;

	inode = new_inode(sb);
	if (inode) {
		struct hugetlbfs_inode_info *info;
		inode->i_mode = mode;
		inode->i_uid = uid;
		inode->i_gid = gid;
		inode->i_blocks = 0;
		inode->i_mapping->a_ops = &hugetlbfs_aops;
		inode->i_mapping->backing_dev_info =&hugetlbfs_backing_dev_info;
		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
505
		INIT_LIST_HEAD(&inode->i_mapping->private_list);
L
Linus Torvalds 已提交
506
		info = HUGETLBFS_I(inode);
507
		mpol_shared_policy_init(&info->policy, NULL);
L
Linus Torvalds 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520
		switch (mode & S_IFMT) {
		default:
			init_special_inode(inode, mode, dev);
			break;
		case S_IFREG:
			inode->i_op = &hugetlbfs_inode_operations;
			inode->i_fop = &hugetlbfs_file_operations;
			break;
		case S_IFDIR:
			inode->i_op = &hugetlbfs_dir_inode_operations;
			inode->i_fop = &simple_dir_operations;

			/* directory inodes start off with i_nlink == 2 (for "." entry) */
521
			inc_nlink(inode);
L
Linus Torvalds 已提交
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
			break;
		case S_IFLNK:
			inode->i_op = &page_symlink_inode_operations;
			break;
		}
	}
	return inode;
}

/*
 * File creation. Allocate an inode, and we're done..
 */
static int hugetlbfs_mknod(struct inode *dir,
			struct dentry *dentry, int mode, dev_t dev)
{
	struct inode *inode;
	int error = -ENOSPC;
	gid_t gid;

	if (dir->i_mode & S_ISGID) {
		gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else {
		gid = current->fsgid;
	}
	inode = hugetlbfs_get_inode(dir->i_sb, current->fsuid, gid, mode, dev);
	if (inode) {
		dir->i_ctime = dir->i_mtime = CURRENT_TIME;
		d_instantiate(dentry, inode);
		dget(dentry);	/* Extra count - pin the dentry in core */
		error = 0;
	}
	return error;
}

static int hugetlbfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	int retval = hugetlbfs_mknod(dir, dentry, mode | S_IFDIR, 0);
	if (!retval)
562
		inc_nlink(dir);
L
Linus Torvalds 已提交
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
	return retval;
}

static int hugetlbfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
{
	return hugetlbfs_mknod(dir, dentry, mode | S_IFREG, 0);
}

static int hugetlbfs_symlink(struct inode *dir,
			struct dentry *dentry, const char *symname)
{
	struct inode *inode;
	int error = -ENOSPC;
	gid_t gid;

	if (dir->i_mode & S_ISGID)
		gid = dir->i_gid;
	else
		gid = current->fsgid;

	inode = hugetlbfs_get_inode(dir->i_sb, current->fsuid,
					gid, S_IFLNK|S_IRWXUGO, 0);
	if (inode) {
		int l = strlen(symname)+1;
		error = page_symlink(inode, symname, l);
		if (!error) {
			d_instantiate(dentry, inode);
			dget(dentry);
		} else
			iput(inode);
	}
	dir->i_ctime = dir->i_mtime = CURRENT_TIME;

	return error;
}

/*
600
 * mark the head page dirty
L
Linus Torvalds 已提交
601 602 603
 */
static int hugetlbfs_set_page_dirty(struct page *page)
{
604
	struct page *head = compound_head(page);
605 606

	SetPageDirty(head);
L
Linus Torvalds 已提交
607 608 609
	return 0;
}

610
static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
611
{
612
	struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb);
L
Linus Torvalds 已提交
613 614 615 616 617

	buf->f_type = HUGETLBFS_MAGIC;
	buf->f_bsize = HPAGE_SIZE;
	if (sbinfo) {
		spin_lock(&sbinfo->stat_lock);
618 619 620 621 622 623 624 625
		/* If no limits set, just report 0 for max/free/used
		 * blocks, like simple_statfs() */
		if (sbinfo->max_blocks >= 0) {
			buf->f_blocks = sbinfo->max_blocks;
			buf->f_bavail = buf->f_bfree = sbinfo->free_blocks;
			buf->f_files = sbinfo->max_inodes;
			buf->f_ffree = sbinfo->free_inodes;
		}
L
Linus Torvalds 已提交
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
		spin_unlock(&sbinfo->stat_lock);
	}
	buf->f_namelen = NAME_MAX;
	return 0;
}

static void hugetlbfs_put_super(struct super_block *sb)
{
	struct hugetlbfs_sb_info *sbi = HUGETLBFS_SB(sb);

	if (sbi) {
		sb->s_fs_info = NULL;
		kfree(sbi);
	}
}

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
static inline int hugetlbfs_dec_free_inodes(struct hugetlbfs_sb_info *sbinfo)
{
	if (sbinfo->free_inodes >= 0) {
		spin_lock(&sbinfo->stat_lock);
		if (unlikely(!sbinfo->free_inodes)) {
			spin_unlock(&sbinfo->stat_lock);
			return 0;
		}
		sbinfo->free_inodes--;
		spin_unlock(&sbinfo->stat_lock);
	}

	return 1;
}

static void hugetlbfs_inc_free_inodes(struct hugetlbfs_sb_info *sbinfo)
{
	if (sbinfo->free_inodes >= 0) {
		spin_lock(&sbinfo->stat_lock);
		sbinfo->free_inodes++;
		spin_unlock(&sbinfo->stat_lock);
	}
}


667
static struct kmem_cache *hugetlbfs_inode_cachep;
L
Linus Torvalds 已提交
668 669 670

static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
{
671
	struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(sb);
L
Linus Torvalds 已提交
672 673
	struct hugetlbfs_inode_info *p;

674 675
	if (unlikely(!hugetlbfs_dec_free_inodes(sbinfo)))
		return NULL;
676
	p = kmem_cache_alloc(hugetlbfs_inode_cachep, GFP_KERNEL);
677 678
	if (unlikely(!p)) {
		hugetlbfs_inc_free_inodes(sbinfo);
L
Linus Torvalds 已提交
679
		return NULL;
680
	}
L
Linus Torvalds 已提交
681 682 683 684 685
	return &p->vfs_inode;
}

static void hugetlbfs_destroy_inode(struct inode *inode)
{
686
	hugetlbfs_inc_free_inodes(HUGETLBFS_SB(inode->i_sb));
L
Linus Torvalds 已提交
687 688 689 690
	mpol_free_shared_policy(&HUGETLBFS_I(inode)->policy);
	kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode));
}

691
static const struct address_space_operations hugetlbfs_aops = {
L
Linus Torvalds 已提交
692
	.readpage	= hugetlbfs_readpage,
N
Nick Piggin 已提交
693 694
	.write_begin	= hugetlbfs_write_begin,
	.write_end	= hugetlbfs_write_end,
L
Linus Torvalds 已提交
695 696 697
	.set_page_dirty	= hugetlbfs_set_page_dirty,
};

698

699
static void init_once(struct kmem_cache *cachep, void *foo)
700 701 702
{
	struct hugetlbfs_inode_info *ei = (struct hugetlbfs_inode_info *)foo;

C
Christoph Lameter 已提交
703
	inode_init_once(&ei->vfs_inode);
704 705
}

706
const struct file_operations hugetlbfs_file_operations = {
B
Badari Pulavarty 已提交
707
	.read			= hugetlbfs_read,
L
Linus Torvalds 已提交
708 709 710 711 712
	.mmap			= hugetlbfs_file_mmap,
	.fsync			= simple_sync_file,
	.get_unmapped_area	= hugetlb_get_unmapped_area,
};

713
static const struct inode_operations hugetlbfs_dir_inode_operations = {
L
Linus Torvalds 已提交
714 715 716 717 718 719 720 721 722 723 724 725
	.create		= hugetlbfs_create,
	.lookup		= simple_lookup,
	.link		= simple_link,
	.unlink		= simple_unlink,
	.symlink	= hugetlbfs_symlink,
	.mkdir		= hugetlbfs_mkdir,
	.rmdir		= simple_rmdir,
	.mknod		= hugetlbfs_mknod,
	.rename		= simple_rename,
	.setattr	= hugetlbfs_setattr,
};

726
static const struct inode_operations hugetlbfs_inode_operations = {
L
Linus Torvalds 已提交
727 728 729
	.setattr	= hugetlbfs_setattr,
};

730
static const struct super_operations hugetlbfs_ops = {
L
Linus Torvalds 已提交
731 732 733
	.alloc_inode    = hugetlbfs_alloc_inode,
	.destroy_inode  = hugetlbfs_destroy_inode,
	.statfs		= hugetlbfs_statfs,
734
	.delete_inode	= hugetlbfs_delete_inode,
L
Linus Torvalds 已提交
735 736
	.drop_inode	= hugetlbfs_drop_inode,
	.put_super	= hugetlbfs_put_super,
M
Miklos Szeredi 已提交
737
	.show_options	= generic_show_options,
L
Linus Torvalds 已提交
738 739 740 741 742
};

static int
hugetlbfs_parse_options(char *options, struct hugetlbfs_config *pconfig)
{
743 744 745
	char *p, *rest;
	substring_t args[MAX_OPT_ARGS];
	int option;
L
Linus Torvalds 已提交
746 747 748 749

	if (!options)
		return 0;

750 751
	while ((p = strsep(&options, ",")) != NULL) {
		int token;
752 753
		if (!*p)
			continue;
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_uid:
			if (match_int(&args[0], &option))
 				goto bad_val;
			pconfig->uid = option;
			break;

		case Opt_gid:
			if (match_int(&args[0], &option))
 				goto bad_val;
			pconfig->gid = option;
			break;

		case Opt_mode:
			if (match_octal(&args[0], &option))
 				goto bad_val;
772
			pconfig->mode = option & 01777U;
773 774 775 776 777 778 779 780
			break;

		case Opt_size: {
 			unsigned long long size;
			/* memparse() will accept a K/M/G without a digit */
			if (!isdigit(*args[0].from))
				goto bad_val;
			size = memparse(args[0].from, &rest);
L
Linus Torvalds 已提交
781 782 783 784 785 786
			if (*rest == '%') {
				size <<= HPAGE_SHIFT;
				size *= max_huge_pages;
				do_div(size, 100);
			}
			pconfig->nr_blocks = (size >> HPAGE_SHIFT);
787 788
			break;
		}
L
Linus Torvalds 已提交
789

790 791 792 793 794 795 796 797
		case Opt_nr_inodes:
			/* memparse() will accept a K/M/G without a digit */
			if (!isdigit(*args[0].from))
				goto bad_val;
			pconfig->nr_inodes = memparse(args[0].from, &rest);
			break;

		default:
798 799 800
			printk(KERN_ERR "hugetlbfs: Bad mount option: \"%s\"\n",
				 p);
			return -EINVAL;
801 802
			break;
		}
L
Linus Torvalds 已提交
803 804
	}
	return 0;
805 806 807 808 809

bad_val:
 	printk(KERN_ERR "hugetlbfs: Bad value '%s' for mount option '%s'\n",
	       args[0].from, p);
 	return 1;
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817 818 819 820
}

static int
hugetlbfs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct inode * inode;
	struct dentry * root;
	int ret;
	struct hugetlbfs_config config;
	struct hugetlbfs_sb_info *sbinfo;

M
Miklos Szeredi 已提交
821 822
	save_mount_options(sb, data);

L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
	config.nr_blocks = -1; /* No limit on size by default */
	config.nr_inodes = -1; /* No limit on number of inodes by default */
	config.uid = current->fsuid;
	config.gid = current->fsgid;
	config.mode = 0755;
	ret = hugetlbfs_parse_options(data, &config);
	if (ret)
		return ret;

	sbinfo = kmalloc(sizeof(struct hugetlbfs_sb_info), GFP_KERNEL);
	if (!sbinfo)
		return -ENOMEM;
	sb->s_fs_info = sbinfo;
	spin_lock_init(&sbinfo->stat_lock);
	sbinfo->max_blocks = config.nr_blocks;
	sbinfo->free_blocks = config.nr_blocks;
	sbinfo->max_inodes = config.nr_inodes;
	sbinfo->free_inodes = config.nr_inodes;
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	sb->s_blocksize = HPAGE_SIZE;
	sb->s_blocksize_bits = HPAGE_SHIFT;
	sb->s_magic = HUGETLBFS_MAGIC;
	sb->s_op = &hugetlbfs_ops;
	sb->s_time_gran = 1;
	inode = hugetlbfs_get_inode(sb, config.uid, config.gid,
					S_IFDIR | config.mode, 0);
	if (!inode)
		goto out_free;

	root = d_alloc_root(inode);
	if (!root) {
		iput(inode);
		goto out_free;
	}
	sb->s_root = root;
	return 0;
out_free:
	kfree(sbinfo);
	return -ENOMEM;
}

864
int hugetlb_get_quota(struct address_space *mapping, long delta)
L
Linus Torvalds 已提交
865 866 867 868 869 870
{
	int ret = 0;
	struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(mapping->host->i_sb);

	if (sbinfo->free_blocks > -1) {
		spin_lock(&sbinfo->stat_lock);
871 872
		if (sbinfo->free_blocks - delta >= 0)
			sbinfo->free_blocks -= delta;
L
Linus Torvalds 已提交
873 874 875 876 877 878 879 880
		else
			ret = -ENOMEM;
		spin_unlock(&sbinfo->stat_lock);
	}

	return ret;
}

881
void hugetlb_put_quota(struct address_space *mapping, long delta)
L
Linus Torvalds 已提交
882 883 884 885 886
{
	struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(mapping->host->i_sb);

	if (sbinfo->free_blocks > -1) {
		spin_lock(&sbinfo->stat_lock);
887
		sbinfo->free_blocks += delta;
L
Linus Torvalds 已提交
888 889 890 891
		spin_unlock(&sbinfo->stat_lock);
	}
}

892 893
static int hugetlbfs_get_sb(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
L
Linus Torvalds 已提交
894
{
895
	return get_sb_nodev(fs_type, flags, data, hugetlbfs_fill_super, mnt);
L
Linus Torvalds 已提交
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
}

static struct file_system_type hugetlbfs_fs_type = {
	.name		= "hugetlbfs",
	.get_sb		= hugetlbfs_get_sb,
	.kill_sb	= kill_litter_super,
};

static struct vfsmount *hugetlbfs_vfsmount;

static int can_do_hugetlb_shm(void)
{
	return likely(capable(CAP_IPC_LOCK) ||
			in_group_p(sysctl_hugetlb_shm_group) ||
			can_do_mlock());
}

913
struct file *hugetlb_file_setup(const char *name, size_t size)
L
Linus Torvalds 已提交
914 915 916 917 918 919 920
{
	int error = -ENOMEM;
	struct file *file;
	struct inode *inode;
	struct dentry *dentry, *root;
	struct qstr quick_string;

921 922 923
	if (!hugetlbfs_vfsmount)
		return ERR_PTR(-ENOENT);

L
Linus Torvalds 已提交
924 925 926 927 928 929 930
	if (!can_do_hugetlb_shm())
		return ERR_PTR(-EPERM);

	if (!user_shm_lock(size, current->user))
		return ERR_PTR(-ENOMEM);

	root = hugetlbfs_vfsmount->mnt_root;
931
	quick_string.name = name;
L
Linus Torvalds 已提交
932 933 934 935 936 937 938 939 940 941
	quick_string.len = strlen(quick_string.name);
	quick_string.hash = 0;
	dentry = d_alloc(root, &quick_string);
	if (!dentry)
		goto out_shm_unlock;

	error = -ENOSPC;
	inode = hugetlbfs_get_inode(root->d_sb, current->fsuid,
				current->fsgid, S_IFREG | S_IRWXUGO, 0);
	if (!inode)
942
		goto out_dentry;
L
Linus Torvalds 已提交
943

944
	error = -ENOMEM;
945
	if (hugetlb_reserve_pages(inode, 0, size >> HPAGE_SHIFT, NULL))
946 947
		goto out_inode;

L
Linus Torvalds 已提交
948 949 950
	d_instantiate(dentry, inode);
	inode->i_size = size;
	inode->i_nlink = 0;
951 952 953 954 955 956

	error = -ENFILE;
	file = alloc_file(hugetlbfs_vfsmount, dentry,
			FMODE_WRITE | FMODE_READ,
			&hugetlbfs_file_operations);
	if (!file)
957
		goto out_dentry; /* inode is already attached */
958

L
Linus Torvalds 已提交
959 960
	return file;

961 962
out_inode:
	iput(inode);
L
Linus Torvalds 已提交
963 964 965 966 967 968 969 970 971 972 973 974
out_dentry:
	dput(dentry);
out_shm_unlock:
	user_shm_unlock(size, current->user);
	return ERR_PTR(error);
}

static int __init init_hugetlbfs_fs(void)
{
	int error;
	struct vfsmount *vfsmount;

P
Peter Zijlstra 已提交
975 976 977 978
	error = bdi_init(&hugetlbfs_backing_dev_info);
	if (error)
		return error;

L
Linus Torvalds 已提交
979 980
	hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache",
					sizeof(struct hugetlbfs_inode_info),
981
					0, 0, init_once);
L
Linus Torvalds 已提交
982
	if (hugetlbfs_inode_cachep == NULL)
P
Peter Zijlstra 已提交
983
		goto out2;
L
Linus Torvalds 已提交
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000

	error = register_filesystem(&hugetlbfs_fs_type);
	if (error)
		goto out;

	vfsmount = kern_mount(&hugetlbfs_fs_type);

	if (!IS_ERR(vfsmount)) {
		hugetlbfs_vfsmount = vfsmount;
		return 0;
	}

	error = PTR_ERR(vfsmount);

 out:
	if (error)
		kmem_cache_destroy(hugetlbfs_inode_cachep);
P
Peter Zijlstra 已提交
1001 1002
 out2:
	bdi_destroy(&hugetlbfs_backing_dev_info);
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009
	return error;
}

static void __exit exit_hugetlbfs_fs(void)
{
	kmem_cache_destroy(hugetlbfs_inode_cachep);
	unregister_filesystem(&hugetlbfs_fs_type);
P
Peter Zijlstra 已提交
1010
	bdi_destroy(&hugetlbfs_backing_dev_info);
L
Linus Torvalds 已提交
1011 1012 1013 1014 1015 1016
}

module_init(init_hugetlbfs_fs)
module_exit(exit_hugetlbfs_fs)

MODULE_LICENSE("GPL");