lael-labs/linux

Documentation/filesystems/caching/backend-api.txt+23−0

@@ -676,6 +676,29 @@ FS-Cache provides some utilities that a cache backend may make use of: · 675 unmodified lines
676	as possible.	676	as possible.
677		677
678		678
		679	(*) Indicate that a stale object was found and discarded:
		680
		681	void fscache_object_retrying_stale(struct fscache_object *object);
		682
		683	This is called to indicate that the lookup procedure found an object in
		684	the cache that the netfs decided was stale. The object has been
		685	discarded from the cache and the lookup will be performed again.
		686
		687
		688	(*) Indicate that the caching backend killed an object:
		689
		690	void fscache_object_mark_killed(struct fscache_object *object,
		691	enum fscache_why_object_killed why);
		692
		693	This is called to indicate that the cache backend preemptively killed an
		694	object. The why parameter should be set to indicate the reason:
		695
		696	FSCACHE_OBJECT_IS_STALE - the object was stale and needs discarding.
		697	FSCACHE_OBJECT_NO_SPACE - there was insufficient cache space
		698	FSCACHE_OBJECT_WAS_RETIRED - the object was retired when relinquished.
		699	FSCACHE_OBJECT_WAS_CULLED - the object was culled to make space.
		700
		701
679	(*) Get and release references on a retrieval record:	702	(*) Get and release references on a retrieval record:
680		703
681	void fscache_get_retrieval(struct fscache_retrieval *op);	704	void fscache_get_retrieval(struct fscache_retrieval *op);

Documentation/filesystems/caching/fscache.txt+6−1

 		enq=N	Number of times async ops queued for processing
 		can=N	Number of async ops cancelled
 		rej=N	Number of async ops rejected due to object lookup/create failure
+		ini=N	Number of async ops initialised
 		dfr=N	Number of async ops queued for deferred release
-		rel=N	Number of async ops released
+		rel=N	Number of async ops released (should equal ini=N when idle)
 		gc=N	Number of deferred-release async ops garbage collected
 	CacheOp	alo=N	Number of in-progress alloc_object() cache ops
 		luo=N	Number of in-progress lookup_object() cache ops
 		wrp=N	Number of in-progress write_page() cache ops
 		ucp=N	Number of in-progress uncache_page() cache ops
 		dsp=N	Number of in-progress dissociate_pages() cache ops
+	CacheEv	nsp=N	Number of object lookups/creations rejected due to lack of space
+		stl=N	Number of stale objects deleted
+		rtr=N	Number of objects retired when relinquished
+		cul=N	Number of objects culled
  (*) /proc/fs/fscache/histogram

Documentation/filesystems/dax.txt+4−2

@@ -18,8 +18,10 @@ Usage · 17 unmodified lines
18	-----	18	-----
19		19
20	If you have a block device which supports DAX, you can make a filesystem	20	If you have a block device which supports DAX, you can make a filesystem
21	on it as usual. When mounting it, use the -o dax option manually	21	on it as usual. The DAX code currently only supports files with a block
22	or add 'dax' to the options in /etc/fstab.	22	size equal to your kernel's PAGE_SIZE, so you may need to specify a block
		23	size when creating the filesystem. When mounting it, use the "-o dax"
		24	option on the command line or add 'dax' to the options in /etc/fstab.
23		25
24		26
25	Implementation Tips for Block Driver Writers	27	Implementation Tips for Block Driver Writers

Documentation/filesystems/porting+4−0

@@ -500,3 +500,7 @@ in your dentry operations instead. · 499 unmodified lines
500	dentry, it does not get nameidata at all and it gets called only when cookie	500	dentry, it does not get nameidata at all and it gets called only when cookie
501	is non-NULL. Note that link body isn't available anymore, so if you need it,	501	is non-NULL. Note that link body isn't available anymore, so if you need it,
502	store it as cookie.	502	store it as cookie.
		503	--
		504	[mandatory]
		505	__fd_install() & fd_install() can now sleep. Callers should not
		506	hold a spinlock or other resources that do not allow a schedule.

arch/arc/kernel/troubleshoot.c+3−7

 	mmput(mm);
 	if (exe_file) {
-		path = exe_file->f_path;
+		path_nm = file_path(exe_file, buf, 255);
-		path_get(&exe_file->f_path);
 		fput(exe_file);
-		path_nm = d_path(&path, buf, 255);
-		path_put(&path);
 	}
 done:
-	pr_info("Path: %s\n", path_nm);
+	pr_info("Path: %s\n", !IS_ERR(path_nm) ? path_nm : "?");
 }
 static void show_faulting_vma(unsigned long address, char *buf)
 	if (vma && (vma->vm_start <= address)) {
 		struct file *file = vma->vm_file;
 		if (file) {
-			struct path *path = &file->f_path;
+			nm = file_path(file, buf, PAGE_SIZE - 1);
-			nm = d_path(path, buf, PAGE_SIZE - 1);
 			inode = file_inode(vma->vm_file);
 			dev = inode->i_sb->s_dev;
 			ino = inode->i_ino;

arch/blackfin/kernel/trace.c+1−1

@@ -136,7 +136,7 @@ void decode_address(char *buf, unsigned long address) · 135 unmodified lines
136	struct file *file = vma->vm_file;	136	struct file *file = vma->vm_file;
137		137
138	if (file) {	138	if (file) {
139	char *d_name = d_path(&file->f_path, _tmpbuf,	139	char *d_name = file_path(file, _tmpbuf,
140	sizeof(_tmpbuf));	140	sizeof(_tmpbuf));
141	if (!IS_ERR(d_name))	141	if (!IS_ERR(d_name))
142	name = d_name;	142	name = d_name;

arch/powerpc/platforms/cell/spufs/inode.c+1−1

@@ -166,7 +166,7 @@ static void spufs_prune_dir(struct dentry *dir) · 165 unmodified lines
166	mutex_lock(&d_inode(dir)->i_mutex);	166	mutex_lock(&d_inode(dir)->i_mutex);
167	list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {	167	list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
168	spin_lock(&dentry->d_lock);	168	spin_lock(&dentry->d_lock);
169	if (!(d_unhashed(dentry)) && d_really_is_positive(dentry)) {	169	if (simple_positive(dentry)) {
170	dget_dlock(dentry);	170	dget_dlock(dentry);
171	__d_drop(dentry);	171	__d_drop(dentry);
172	spin_unlock(&dentry->d_lock);	172	spin_unlock(&dentry->d_lock);

arch/s390/hypfs/inode.c+1−6

 	hypfs_last_dentry = dentry;
 }
-static inline int hypfs_positive(struct dentry *dentry)
-{
-	return d_really_is_positive(dentry) && !d_unhashed(dentry);
-}
 static void hypfs_remove(struct dentry *dentry)
 {
 	struct dentry *parent;
 	parent = dentry->d_parent;
 	mutex_lock(&d_inode(parent)->i_mutex);
-	if (hypfs_positive(dentry)) {
+	if (simple_positive(dentry)) {
 		if (d_is_dir(dentry))
 			simple_rmdir(d_inode(parent), dentry);
 		else

arch/tile/kernel/stack.c+1−1

@@ -332,7 +332,7 @@ static void describe_addr(struct KBacktraceIterator *kbt, · 331 unmodified lines
332	}	332	}
333		333
334	if (vma->vm_file) {	334	if (vma->vm_file) {
335	p = d_path(&vma->vm_file->f_path, buf, bufsize);	335	p = file_path(vma->vm_file, buf, bufsize);
336	if (IS_ERR(p))	336	if (IS_ERR(p))
337	p = "?";	337	p = "?";
338	name = kbasename(p);	338	name = kbasename(p);

arch/tile/mm/elf.c+1−1

@@ -56,7 +56,7 @@ static int notify_exec(struct mm_struct *mm) · 55 unmodified lines
56	if (exe_file == NULL)	56	if (exe_file == NULL)
57	goto done_free;	57	goto done_free;
58		58
59	path = d_path(&exe_file->f_path, buf, PAGE_SIZE);	59	path = file_path(exe_file, buf, PAGE_SIZE);
60	if (IS_ERR(path))	60	if (IS_ERR(path))
61	goto done_put;	61	goto done_put;
62		62

drivers/block/drbd/drbd_debugfs.c+1−9

 	return 0;
 }
-/* simple_positive(file->f_path.dentry) respectively debugfs_positive(),
- * but neither is "reachable" from here.
- * So we have our own inline version of it above.  :-( */
-static inline int debugfs_positive(struct dentry *dentry)
-{
-        return d_really_is_positive(dentry) && !d_unhashed(dentry);
-}
 /* make sure at *open* time that the respective object won't go away. */
 static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, void *),
 		                void *data, struct kref *kref,
 	/* serialize with d_delete() */
 	mutex_lock(&d_inode(parent)->i_mutex);
 	/* Make sure the object is still alive */
-	if (debugfs_positive(file->f_path.dentry)
+	if (simple_positive(file->f_path.dentry)
 	&& kref_get_unless_zero(kref))
 		ret = 0;
 	mutex_unlock(&d_inode(parent)->i_mutex);

drivers/block/loop.c+1−1

@@ -588,7 +588,7 @@ static ssize_t loop_attr_backing_file_show(struct loop_device lo, char buf) · 587 unmodified lines
588		588
589	spin_lock_irq(&lo->lo_lock);	589	spin_lock_irq(&lo->lo_lock);
590	if (lo->lo_backing_file)	590	if (lo->lo_backing_file)
591	p = d_path(&lo->lo_backing_file->f_path, buf, PAGE_SIZE - 1);	591	p = file_path(lo->lo_backing_file, buf, PAGE_SIZE - 1);
592	spin_unlock_irq(&lo->lo_lock);	592	spin_unlock_irq(&lo->lo_lock);
593		593
594	if (IS_ERR_OR_NULL(p))	594	if (IS_ERR_OR_NULL(p))

drivers/infiniband/hw/ipath/ipath_fs.c+1−1

@@ -277,7 +277,7 @@ static int remove_file(struct dentry parent, char name) · 276 unmodified lines
277	}	277	}
278		278
279	spin_lock(&tmp->d_lock);	279	spin_lock(&tmp->d_lock);
280	if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {	280	if (simple_positive(tmp)) {
281	dget_dlock(tmp);	281	dget_dlock(tmp);
282	__d_drop(tmp);	282	__d_drop(tmp);
283	spin_unlock(&tmp->d_lock);	283	spin_unlock(&tmp->d_lock);

drivers/infiniband/hw/qib/qib_fs.c+1−1

@@ -455,7 +455,7 @@ static int remove_file(struct dentry parent, char name) · 454 unmodified lines
455	}	455	}
456		456
457	spin_lock(&tmp->d_lock);	457	spin_lock(&tmp->d_lock);
458	if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {	458	if (simple_positive(tmp)) {
459	__d_drop(tmp);	459	__d_drop(tmp);
460	spin_unlock(&tmp->d_lock);	460	spin_unlock(&tmp->d_lock);
461	simple_unlink(d_inode(parent), tmp);	461	simple_unlink(d_inode(parent), tmp);

drivers/md/bitmap.c+2−2

@@ -839,7 +839,7 @@ static void bitmap_file_kick(struct bitmap *bitmap) · 838 unmodified lines
839	if (bitmap->storage.file) {	839	if (bitmap->storage.file) {
840	path = kmalloc(PAGE_SIZE, GFP_KERNEL);	840	path = kmalloc(PAGE_SIZE, GFP_KERNEL);
841	if (path)	841	if (path)
842	ptr = d_path(&bitmap->storage.file->f_path,	842	ptr = file_path(bitmap->storage.file,
843	path, PAGE_SIZE);	843	path, PAGE_SIZE);
844		844
845	printk(KERN_ALERT	845	printk(KERN_ALERT
@@ -1927,7 +1927,7 @@ void bitmap_status(struct seq_file seq, struct bitmap bitmap) · 1081 unmodified lines
1927	chunk_kb ? "KB" : "B");	1927	chunk_kb ? "KB" : "B");
1928	if (bitmap->storage.file) {	1928	if (bitmap->storage.file) {
1929	seq_printf(seq, ", file: ");	1929	seq_printf(seq, ", file: ");
1930	seq_path(seq, &bitmap->storage.file->f_path, " \t\n");	1930	seq_file_path(seq, bitmap->storage.file, " \t\n");
1931	}	1931	}
1932		1932
1933	seq_printf(seq, "\n");	1933	seq_printf(seq, "\n");

drivers/md/md.c+1−1

@@ -5766,7 +5766,7 @@ static int get_bitmap_file(struct mddev mddev, void __user arg) · 5765 unmodified lines
5766	/* bitmap disabled, zero the first byte and copy out */	5766	/* bitmap disabled, zero the first byte and copy out */
5767	if (!mddev->bitmap_info.file)	5767	if (!mddev->bitmap_info.file)
5768	file->pathname[0] = '\0';	5768	file->pathname[0] = '\0';
5769	else if ((ptr = d_path(&mddev->bitmap_info.file->f_path,	5769	else if ((ptr = file_path(mddev->bitmap_info.file,
5770	file->pathname, sizeof(file->pathname))),	5770	file->pathname, sizeof(file->pathname))),
5771	IS_ERR(ptr))	5771	IS_ERR(ptr))
5772	err = PTR_ERR(ptr);	5772	err = PTR_ERR(ptr);

drivers/usb/gadget/function/f_mass_storage.c+1−1

@@ -2936,7 +2936,7 @@ int fsg_common_create_lun(struct fsg_common common, struct fsg_lun_config cfg, · 2935 unmodified lines
2936	if (fsg_lun_is_open(lun)) {	2936	if (fsg_lun_is_open(lun)) {
2937	p = "(error)";	2937	p = "(error)";
2938	if (pathbuf) {	2938	if (pathbuf) {
2939	p = d_path(&lun->filp->f_path, pathbuf, PATH_MAX);	2939	p = file_path(lun->filp, pathbuf, PATH_MAX);
2940	if (IS_ERR(p))	2940	if (IS_ERR(p))
2941	p = "(error)";	2941	p = "(error)";
2942	}	2942	}

drivers/usb/gadget/function/storage_common.c+1−1

@@ -341,7 +341,7 @@ ssize_t fsg_show_file(struct fsg_lun curlun, struct rw_semaphore filesem, · 340 unmodified lines
341		341
342	down_read(filesem);	342	down_read(filesem);
343	if (fsg_lun_is_open(curlun)) { /* Get the complete pathname */	343	if (fsg_lun_is_open(curlun)) { /* Get the complete pathname */
344	p = d_path(&curlun->filp->f_path, buf, PAGE_SIZE - 1);	344	p = file_path(curlun->filp, buf, PAGE_SIZE - 1);
345	if (IS_ERR(p))	345	if (IS_ERR(p))
346	rc = PTR_ERR(p);	346	rc = PTR_ERR(p);
347	else {	347	else {

fs/affs/affs.h+1−1

@@ -64,7 +64,7 @@ struct affs_inode_info { · 63 unmodified lines
64	/* short cut to get to the affs specific inode data */	64	/* short cut to get to the affs specific inode data */
65	static inline struct affs_inode_info AFFS_I(struct inode inode)	65	static inline struct affs_inode_info AFFS_I(struct inode inode)
66	{	66	{
67	return list_entry(inode, struct affs_inode_info, vfs_inode);	67	return container_of(inode, struct affs_inode_info, vfs_inode);
68	}	68	}
69		69
70	/*	70	/*

fs/autofs4/autofs_i.h+0−5

 	return d_inode(sbi->sb->s_root)->i_ino;
 }
-static inline int simple_positive(struct dentry *dentry)
-{
-	return d_really_is_positive(dentry) && !d_unhashed(dentry);
-}
 static inline void __autofs4_add_expiring(struct dentry *dentry)
 {
 	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);

fs/befs/befs.h+1−1

@@ -112,7 +112,7 @@ BEFS_SB(const struct super_block *super) · 111 unmodified lines
112	static inline struct befs_inode_info *	112	static inline struct befs_inode_info *
113	BEFS_I(const struct inode *inode)	113	BEFS_I(const struct inode *inode)
114	{	114	{
115	return list_entry(inode, struct befs_inode_info, vfs_inode);	115	return container_of(inode, struct befs_inode_info, vfs_inode);
116	}	116	}
117		117
118	static inline befs_blocknr_t	118	static inline befs_blocknr_t

fs/binfmt_elf.c+2−2

@@ -1530,7 +1530,7 @@ static int fill_files_note(struct memelfnote *note) · 1529 unmodified lines
1530	file = vma->vm_file;	1530	file = vma->vm_file;
1531	if (!file)	1531	if (!file)
1532	continue;	1532	continue;
1533	filename = d_path(&file->f_path, name_curpos, remaining);	1533	filename = file_path(file, name_curpos, remaining);
1534	if (IS_ERR(filename)) {	1534	if (IS_ERR(filename)) {
1535	if (PTR_ERR(filename) == -ENAMETOOLONG) {	1535	if (PTR_ERR(filename) == -ENAMETOOLONG) {
1536	vfree(data);	1536	vfree(data);
@@ -1540,7 +1540,7 @@ static int fill_files_note(struct memelfnote *note) · 3 unmodified lines
1540	continue;	1540	continue;
1541	}	1541	}
1542		1542
1543	/* d_path() fills at the end, move name down */	1543	/* file_path() fills at the end, move name down */
1544	/* n = strlen(filename) + 1: */	1544	/* n = strlen(filename) + 1: */
1545	n = (name_curpos + remaining) - filename;	1545	n = (name_curpos + remaining) - filename;
1546	remaining = filename - name_curpos;	1546	remaining = filename - name_curpos;

fs/block_dev.c+10−0

 	struct file *file = iocb->ki_filp;
 	struct inode *inode = file->f_mapping->host;
+	if (IS_DAX(inode))
+		return dax_do_io(iocb, inode, iter, offset, blkdev_get_block,
+				NULL, DIO_SKIP_DIO_COUNT);
 	return __blockdev_direct_IO(iocb, inode, I_BDEV(inode), iter, offset,
 				    blkdev_get_block, NULL, NULL,
 				    DIO_SKIP_DIO_COUNT);
 	long avail;
 	const struct block_device_operations *ops = bdev->bd_disk->fops;
+	/*
+	 * The device driver is allowed to sleep, in order to make the
+	 * memory directly accessible.
+	 */
+	might_sleep();
 	if (size < 0)
 		return size;
 	if (!ops->direct_access)
 		bdev->bd_disk = disk;
 		bdev->bd_queue = disk->queue;
 		bdev->bd_contains = bdev;
+		bdev->bd_inode->i_flags = disk->fops->direct_access ? S_DAX : 0;
 		if (!partno) {
 			ret = -ENXIO;
 			bdev->bd_part = disk_get_part(disk, partno);

fs/btrfs/file.c+1−1

@@ -1748,7 +1748,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb, · 1747 unmodified lines
1748	}	1748	}
1749		1749
1750	current->backing_dev_info = inode_to_bdi(inode);	1750	current->backing_dev_info = inode_to_bdi(inode);
1751	err = file_remove_suid(file);	1751	err = file_remove_privs(file);
1752	if (err) {	1752	if (err) {
1753	mutex_unlock(&inode->i_mutex);	1753	mutex_unlock(&inode->i_mutex);
1754	goto out;	1754	goto out;

fs/cachefiles/internal.h+0−1

@@ -43,7 +43,6 @@ struct cachefiles_object { · 42 unmodified lines
43	loff_t i_size; /* object size */	43	loff_t i_size; /* object size */
44	unsigned long flags;	44	unsigned long flags;
45	#define CACHEFILES_OBJECT_ACTIVE 0 /* T if marked active */	45	#define CACHEFILES_OBJECT_ACTIVE 0 /* T if marked active */
46	#define CACHEFILES_OBJECT_BURIED 1 /* T if preemptively buried */
47	atomic_t usage; /* object usage count */	46	atomic_t usage; /* object usage count */
48	uint8_t type; /* object type */	47	uint8_t type; /* object type */
49	uint8_t new; /* T if object new */	48	uint8_t new; /* T if object new */

fs/cachefiles/namei.c+21−12

  *   call vfs_unlink(), vfs_rmdir() or vfs_rename()
  */
 static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
-					  struct dentry *dentry)
+					  struct dentry *dentry,
+					  enum fscache_why_object_killed why)
 {
 	struct cachefiles_object *object;
 	struct rb_node *p;
 		pr_err("\n");
 		pr_err("Error: Can't preemptively bury live object\n");
 		cachefiles_printk_object(object, NULL);
-	} else if (test_and_set_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
+	} else {
-		pr_err("Error: Object already preemptively buried\n");
+		if (why != FSCACHE_OBJECT_IS_STALE)
+			fscache_object_mark_killed(&object->fscache, why);
 	}
 	write_unlock(&cache->active_lock);
 static int cachefiles_bury_object(struct cachefiles_cache *cache,
 				  struct dentry *dir,
 				  struct dentry *rep,
-				  bool preemptive)
+				  bool preemptive,
+				  enum fscache_why_object_killed why)
 {
 	struct dentry *grave, *trap;
 	struct path path, path_to_graveyard;
 			ret = vfs_unlink(d_inode(dir), rep, NULL);
 			if (preemptive)
-				cachefiles_mark_object_buried(cache, rep);
+				cachefiles_mark_object_buried(cache, rep, why);
 		}
 		mutex_unlock(&d_inode(dir)->i_mutex);
 					    "Rename failed with error %d", ret);
 		if (preemptive)
-			cachefiles_mark_object_buried(cache, rep);
+			cachefiles_mark_object_buried(cache, rep, why);
 	}
 	unlock_rename(cache->graveyard, dir);
 	mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
-	if (test_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) {
+	if (test_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->fscache.flags)) {
 		/* object allocation for the same key preemptively deleted this
 		 * object's file so that it could create its own file */
 		_debug("object preemptively buried");
 		 * may have been renamed */
 		if (dir == object->dentry->d_parent) {
 			ret = cachefiles_bury_object(cache, dir,
-						     object->dentry, false);
+						     object->dentry, false,
+						     FSCACHE_OBJECT_WAS_RETIRED);
 		} else {
 			/* it got moved, presumably by cachefilesd culling it,
 			 * so it's no longer in the key path and we can ignore
 		if (d_is_negative(next)) {
 			ret = cachefiles_has_space(cache, 1, 0);
 			if (ret < 0)
-				goto create_error;
+				goto no_space_error;
 			path.dentry = dir;
 			ret = security_path_mkdir(&path, next, 0);
 		if (d_is_negative(next)) {
 			ret = cachefiles_has_space(cache, 1, 0);
 			if (ret < 0)
-				goto create_error;
+				goto no_space_error;
 			path.dentry = dir;
 			ret = security_path_mknod(&path, next, S_IFREG, 0);
 			 * mutex) */
 			object->dentry = NULL;
-			ret = cachefiles_bury_object(cache, dir, next, true);
+			ret = cachefiles_bury_object(cache, dir, next, true,
+						     FSCACHE_OBJECT_IS_STALE);
 			dput(next);
 			next = NULL;
 				goto delete_error;
 			_debug("redo lookup");
+			fscache_object_retrying_stale(&object->fscache);
 			goto lookup_again;
 		}
 	}
 	_leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
 	return 0;
+no_space_error:
+	fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
 create_error:
 	_debug("create error %d", ret);
 	if (ret == -EIO)
 	/*  actually remove the victim (drops the dir mutex) */
 	_debug("bury");
-	ret = cachefiles_bury_object(cache, dir, victim, false);
+	ret = cachefiles_bury_object(cache, dir, victim, false,
+				     FSCACHE_OBJECT_WAS_CULLED);
 	if (ret < 0)
 		goto error;

fs/ceph/file.c+1−1

@@ -962,7 +962,7 @@ static ssize_t ceph_write_iter(struct kiocb iocb, struct iov_iter from) · 961 unmodified lines
962		962
963	pos = iocb->ki_pos;	963	pos = iocb->ki_pos;
964	count = iov_iter_count(from);	964	count = iov_iter_count(from);
965	err = file_remove_suid(file);	965	err = file_remove_privs(file);
966	if (err)	966	if (err)
967	goto out;	967	goto out;
968		968

fs/coda/coda_linux.h+1−1

@@ -79,7 +79,7 @@ void coda_sysctl_clean(void); · 78 unmodified lines
79		79
80	static inline struct coda_inode_info ITOC(struct inode inode)	80	static inline struct coda_inode_info ITOC(struct inode inode)
81	{	81	{
82	return list_entry(inode, struct coda_inode_info, vfs_inode);	82	return container_of(inode, struct coda_inode_info, vfs_inode);
83	}	83	}
84		84
85	static __inline__ struct CodaFid coda_i2f(struct inode inode)	85	static __inline__ struct CodaFid coda_i2f(struct inode inode)

fs/configfs/inode.c+1−1

@@ -236,7 +236,7 @@ void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent) · 235 unmodified lines
236		236
237	if (dentry) {	237	if (dentry) {
238	spin_lock(&dentry->d_lock);	238	spin_lock(&dentry->d_lock);
239	if (!d_unhashed(dentry) && d_really_is_positive(dentry)) {	239	if (simple_positive(dentry)) {
240	dget_dlock(dentry);	240	dget_dlock(dentry);
241	__d_drop(dentry);	241	__d_drop(dentry);
242	spin_unlock(&dentry->d_lock);	242	spin_unlock(&dentry->d_lock);

fs/coredump.c+1−1

@@ -140,7 +140,7 @@ static int cn_print_exe_file(struct core_name *cn) · 139 unmodified lines
140	goto put_exe_file;	140	goto put_exe_file;
141	}	141	}
142		142
143	path = d_path(&exe_file->f_path, pathbuf, PATH_MAX);	143	path = file_path(exe_file, pathbuf, PATH_MAX);
144	if (IS_ERR(path)) {	144	if (IS_ERR(path)) {
145	ret = PTR_ERR(path);	145	ret = PTR_ERR(path);
146	goto free_buf;	146	goto free_buf;

fs/dax.c+5−3

 		}
 		if (iov_iter_rw(iter) == WRITE)
-			len = copy_from_iter(addr, max - pos, iter);
+			len = copy_from_iter_nocache(addr, max - pos, iter);
 		else if (!hole)
 			len = copy_to_iter(addr, max - pos, iter);
 		else
 	}
 	/* Protects against truncate */
-	inode_dio_begin(inode);
+	if (!(flags & DIO_SKIP_DIO_COUNT))
+		inode_dio_begin(inode);
 	retval = dax_io(inode, iter, pos, end, get_block, &bh);
 	if ((retval > 0) && end_io)
 		end_io(iocb, pos, retval, bh.b_private);
-	inode_dio_end(inode);
+	if (!(flags & DIO_SKIP_DIO_COUNT))
+		inode_dio_end(inode);
  out:
 	return retval;
 }

fs/dcache.c+4−1

 				DCACHE_OP_COMPARE	|
 				DCACHE_OP_REVALIDATE	|
 				DCACHE_OP_WEAK_REVALIDATE	|
-				DCACHE_OP_DELETE ));
+				DCACHE_OP_DELETE	|
+				DCACHE_OP_SELECT_INODE));
 	dentry->d_op = op;
 	if (!op)
 		return;
 		dentry->d_flags |= DCACHE_OP_DELETE;
 	if (op->d_prune)
 		dentry->d_flags |= DCACHE_OP_PRUNE;
+	if (op->d_select_inode)
+		dentry->d_flags |= DCACHE_OP_SELECT_INODE;
 }
 EXPORT_SYMBOL(d_set_d_op);

fs/debugfs/inode.c+3−8

 	return inode;
 }
-static inline int debugfs_positive(struct dentry *dentry)
-{
-	return d_really_is_positive(dentry) && !d_unhashed(dentry);
-}
 struct debugfs_mount_opts {
 	kuid_t uid;
 	kgid_t gid;
 {
 	int ret = 0;
-	if (debugfs_positive(dentry)) {
+	if (simple_positive(dentry)) {
 		dget(dentry);
 		if (d_is_dir(dentry))
 			ret = simple_rmdir(d_inode(parent), dentry);
 	 */
 	spin_lock(&parent->d_lock);
 	list_for_each_entry(child, &parent->d_subdirs, d_child) {
-		if (!debugfs_positive(child))
+		if (!simple_positive(child))
 			continue;
 		/* perhaps simple_empty(child) makes more sense */
 		 * from d_subdirs. When releasing the parent->d_lock we can
 		 * no longer trust that the next pointer is valid.
 		 * Restart the loop. We'll skip this one with the
-		 * debugfs_positive() check.
+		 * simple_positive() check.
 		 */
 		goto loop;
 	}

fs/exofs/dir.c+0−6

 	page_cache_release(page);
 }
-/* Accesses dir's inode->i_size must be called under inode lock */
-static inline unsigned long dir_pages(struct inode *inode)
-{
-	return (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-}
 static unsigned exofs_last_byte(struct inode *inode, unsigned long page_nr)
 {
 	loff_t last_byte = inode->i_size;

fs/ext2/dir.c+0−5

 	page_cache_release(page);
 }
-static inline unsigned long dir_pages(struct inode *inode)
-{
-	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
-}
 /*
  * Return the offset into page `page_nr' of the last valid
  * byte in that page, plus one.

fs/ext4/super.c+1−1

@@ -452,7 +452,7 @@ void __ext4_error_file(struct file file, const char function, · 451 unmodified lines
452	es = EXT4_SB(inode->i_sb)->s_es;	452	es = EXT4_SB(inode->i_sb)->s_es;
453	es->s_last_error_ino = cpu_to_le32(inode->i_ino);	453	es->s_last_error_ino = cpu_to_le32(inode->i_ino);
454	if (ext4_error_ratelimit(inode->i_sb)) {	454	if (ext4_error_ratelimit(inode->i_sb)) {
455	path = d_path(&(file->f_path), pathname, sizeof(pathname));	455	path = file_path(file, pathname, sizeof(pathname));
456	if (IS_ERR(path))	456	if (IS_ERR(path))
457	path = "(unknown)";	457	path = "(unknown)";
458	va_start(args, fmt);	458	va_start(args, fmt);

fs/file.c+56−21

@@ -147,6 +147,13 @@ static int expand_fdtable(struct files_struct *files, int nr) · 146 unmodified lines
147		147
148	spin_unlock(&files->file_lock);	148	spin_unlock(&files->file_lock);
149	new_fdt = alloc_fdtable(nr);	149	new_fdt = alloc_fdtable(nr);
		150
		151	/* make sure all __fd_install() have seen resize_in_progress
		152	* or have finished their rcu_read_lock_sched() section.
		153	*/
		154	if (atomic_read(&files->count) > 1)
		155	synchronize_sched();
		156
150	spin_lock(&files->file_lock);	157	spin_lock(&files->file_lock);
151	if (!new_fdt)	158	if (!new_fdt)
152	return -ENOMEM;	159	return -ENOMEM;
@@ -158,21 +165,14 @@ static int expand_fdtable(struct files_struct *files, int nr) · 5 unmodified lines
158	__free_fdtable(new_fdt);	165	__free_fdtable(new_fdt);
159	return -EMFILE;	166	return -EMFILE;
160	}	167	}
161	/*
162	* Check again since another task may have expanded the fd table while
163	* we dropped the lock
164	*/
165	cur_fdt = files_fdtable(files);	168	cur_fdt = files_fdtable(files);
166	if (nr >= cur_fdt->max_fds) {	169	BUG_ON(nr < cur_fdt->max_fds);
167	/* Continue as planned */	170	copy_fdtable(new_fdt, cur_fdt);
168	copy_fdtable(new_fdt, cur_fdt);	171	rcu_assign_pointer(files->fdt, new_fdt);
169	rcu_assign_pointer(files->fdt, new_fdt);	172	if (cur_fdt != &files->fdtab)
170	if (cur_fdt != &files->fdtab)	173	call_rcu(&cur_fdt->rcu, free_fdtable_rcu);
171	call_rcu(&cur_fdt->rcu, free_fdtable_rcu);	174	/* coupled with smp_rmb() in __fd_install() */
172	} else {	175	smp_wmb();
173	/* Somebody else expanded, so undo our attempt */
174	__free_fdtable(new_fdt);
175	}
176	return 1;	176	return 1;
177	}	177	}
178		178
@@ -185,21 +185,38 @@ static int expand_fdtable(struct files_struct *files, int nr) · 6 unmodified lines
185	* The files->file_lock should be held on entry, and will be held on exit.	185	* The files->file_lock should be held on entry, and will be held on exit.
186	*/	186	*/
187	static int expand_files(struct files_struct *files, int nr)	187	static int expand_files(struct files_struct *files, int nr)
		188	__releases(files->file_lock)
		189	__acquires(files->file_lock)
188	{	190	{
189	struct fdtable *fdt;	191	struct fdtable *fdt;
		192	int expanded = 0;
190		193
		194	repeat:
191	fdt = files_fdtable(files);	195	fdt = files_fdtable(files);
192		196
193	/* Do we need to expand? */	197	/* Do we need to expand? */
194	if (nr < fdt->max_fds)	198	if (nr < fdt->max_fds)
195	return 0;	199	return expanded;
196		200
197	/* Can we expand? */	201	/* Can we expand? */
198	if (nr >= sysctl_nr_open)	202	if (nr >= sysctl_nr_open)
199	return -EMFILE;	203	return -EMFILE;
200		204
		205	if (unlikely(files->resize_in_progress)) {
		206	spin_unlock(&files->file_lock);
		207	expanded = 1;
		208	wait_event(files->resize_wait, !files->resize_in_progress);
		209	spin_lock(&files->file_lock);
		210	goto repeat;
		211	}
		212
201	/* All good, so we try */	213	/* All good, so we try */
202	return expand_fdtable(files, nr);	214	files->resize_in_progress = true;
		215	expanded = expand_fdtable(files, nr);
		216	files->resize_in_progress = false;
		217
		218	wake_up_all(&files->resize_wait);
		219	return expanded;
203	}	220	}
204		221
205	static inline void __set_close_on_exec(int fd, struct fdtable *fdt)	222	static inline void __set_close_on_exec(int fd, struct fdtable *fdt)
@@ -256,6 +273,8 @@ struct files_struct dup_fd(struct files_struct oldf, int *errorp) · 50 unmodified lines
256	atomic_set(&newf->count, 1);	273	atomic_set(&newf->count, 1);
257		274
258	spin_lock_init(&newf->file_lock);	275	spin_lock_init(&newf->file_lock);
		276	newf->resize_in_progress = false;
		277	init_waitqueue_head(&newf->resize_wait);
259	newf->next_fd = 0;	278	newf->next_fd = 0;
260	new_fdt = &newf->fdtab;	279	new_fdt = &newf->fdtab;
261	new_fdt->max_fds = NR_OPEN_DEFAULT;	280	new_fdt->max_fds = NR_OPEN_DEFAULT;
@@ -553,11 +572,21 @@ void __fd_install(struct files_struct *files, unsigned int fd, · 291 unmodified lines
553	struct file *file)	572	struct file *file)
554	{	573	{
555	struct fdtable *fdt;	574	struct fdtable *fdt;
556	spin_lock(&files->file_lock);	575
557	fdt = files_fdtable(files);	576	might_sleep();
		577	rcu_read_lock_sched();
		578
		579	while (unlikely(files->resize_in_progress)) {
		580	rcu_read_unlock_sched();
		581	wait_event(files->resize_wait, !files->resize_in_progress);
		582	rcu_read_lock_sched();
		583	}
		584	/* coupled with smp_wmb() in expand_fdtable() */
		585	smp_rmb();
		586	fdt = rcu_dereference_sched(files->fdt);
558	BUG_ON(fdt->fd[fd] != NULL);	587	BUG_ON(fdt->fd[fd] != NULL);
559	rcu_assign_pointer(fdt->fd[fd], file);	588	rcu_assign_pointer(fdt->fd[fd], file);
560	spin_unlock(&files->file_lock);	589	rcu_read_unlock_sched();
561	}	590	}
562		591
563	void fd_install(unsigned int fd, struct file *file)	592	void fd_install(unsigned int fd, struct file *file)
@@ -635,11 +664,17 @@ static struct file *__fget(unsigned int fd, fmode_t mask) · 71 unmodified lines
635	struct file *file;	664	struct file *file;
636		665
637	rcu_read_lock();	666	rcu_read_lock();
		667	loop:
638	file = fcheck_files(files, fd);	668	file = fcheck_files(files, fd);
639	if (file) {	669	if (file) {
640	/* File object ref couldn't be taken */	670	/* File object ref couldn't be taken.
641	if ((file->f_mode & mask) \|\| !get_file_rcu(file))	671	* dup2() atomicity guarantee is the reason
		672	* we loop to catch the new file (or NULL pointer)
		673	*/
		674	if (file->f_mode & mask)
642	file = NULL;	675	file = NULL;
		676	else if (!get_file_rcu(file))
		677	goto loop;
643	}	678	}
644	rcu_read_unlock();	679	rcu_read_unlock();
645		680

fs/file_table.c+0−1

@@ -20,7 +20,6 @@ · 19 unmodified lines
20	#include <linux/cdev.h>	20	#include <linux/cdev.h>
21	#include <linux/fsnotify.h>	21	#include <linux/fsnotify.h>
22	#include <linux/sysctl.h>	22	#include <linux/sysctl.h>
23	#include <linux/lglock.h>
24	#include <linux/percpu_counter.h>	23	#include <linux/percpu_counter.h>
25	#include <linux/percpu.h>	24	#include <linux/percpu.h>
26	#include <linux/hardirq.h>	25	#include <linux/hardirq.h>

fs/freevxfs/vxfs_lookup.c+0−7

@@ -61,13 +61,6 @@ const struct file_operations vxfs_dir_operations = { · 60 unmodified lines
61	.iterate = vxfs_readdir,	61	.iterate = vxfs_readdir,
62	};	62	};
63		63
64
65	static inline u_long
66	dir_pages(struct inode *inode)
67	{
68	return (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
69	}
70
71	static inline u_long	64	static inline u_long
72	dir_blocks(struct inode *ip)	65	dir_blocks(struct inode *ip)
73	{	66	{

fs/fscache/cookie.c+4−4

 object_already_extant:
 	ret = -ENOBUFS;
-	if (fscache_object_is_dead(object)) {
+	if (fscache_object_is_dying(object) ||
+	    fscache_cache_is_broken(object)) {
 		spin_unlock(&cookie->lock);
 		goto error;
 	}
 	if (!op)
 		return -ENOMEM;
-	fscache_operation_init(op, NULL, NULL);
+	fscache_operation_init(op, NULL, NULL, NULL);
 	op->flags = FSCACHE_OP_MYTHREAD |
 		(1 << FSCACHE_OP_WAITING) |
 		(1 << FSCACHE_OP_UNUSE_COOKIE);
 	/* the work queue now carries its own ref on the object */
 	spin_unlock(&cookie->lock);
-	ret = fscache_wait_for_operation_activation(object, op,
+	ret = fscache_wait_for_operation_activation(object, op, NULL, NULL);
-						    NULL, NULL, NULL);
 	if (ret == 0) {
 		/* ask the cache to honour the operation */
 		ret = object->cache->ops->check_consistency(op);

fs/fscache/internal.h+8−4

 				       struct fscache_operation *);
 extern int fscache_submit_op(struct fscache_object *,
 			     struct fscache_operation *);
-extern int fscache_cancel_op(struct fscache_operation *,
+extern int fscache_cancel_op(struct fscache_operation *, bool);
-			     void (*)(struct fscache_operation *));
 extern void fscache_cancel_all_ops(struct fscache_object *);
 extern void fscache_abort_object(struct fscache_object *);
 extern void fscache_start_operations(struct fscache_object *);
 extern int fscache_wait_for_operation_activation(struct fscache_object *,
 						 struct fscache_operation *,
 						 atomic_t *,
-						 atomic_t *,
+						 atomic_t *);
-						 void (*)(struct fscache_operation *));
 extern void fscache_invalidate_writes(struct fscache_cookie *);
 /*
 extern atomic_t fscache_n_op_run;
 extern atomic_t fscache_n_op_enqueue;
 extern atomic_t fscache_n_op_deferred_release;
+extern atomic_t fscache_n_op_initialised;
 extern atomic_t fscache_n_op_release;
 extern atomic_t fscache_n_op_gc;
 extern atomic_t fscache_n_op_cancelled;
 extern atomic_t fscache_n_cop_uncache_page;
 extern atomic_t fscache_n_cop_dissociate_pages;
+extern atomic_t fscache_n_cache_no_space_reject;
+extern atomic_t fscache_n_cache_stale_objects;
+extern atomic_t fscache_n_cache_retired_objects;
+extern atomic_t fscache_n_cache_culled_objects;
 static inline void fscache_stat(atomic_t *stat)
 {
 	atomic_inc(stat);

fs/fscache/object.c+65−4

@@ -327,6 +327,17 @@ void fscache_object_init(struct fscache_object *object, · 326 unmodified lines
327	}	327	}
328	EXPORT_SYMBOL(fscache_object_init);	328	EXPORT_SYMBOL(fscache_object_init);
329		329
		330	/*
		331	* Mark the object as no longer being live, making sure that we synchronise
		332	* against op submission.
		333	*/
		334	static inline void fscache_mark_object_dead(struct fscache_object *object)
		335	{
		336	spin_lock(&object->lock);
		337	clear_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);
		338	spin_unlock(&object->lock);
		339	}
		340
330	/*	341	/*
331	* Abort object initialisation before we start it.	342	* Abort object initialisation before we start it.
332	*/	343	*/
@@ -610,6 +621,8 @@ static const struct fscache_state *fscache_lookup_failure(struct fscache_object · 277 unmodified lines
610	object->cache->ops->lookup_complete(object);	621	object->cache->ops->lookup_complete(object);
611	fscache_stat_d(&fscache_n_cop_lookup_complete);	622	fscache_stat_d(&fscache_n_cop_lookup_complete);
612		623
		624	set_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->flags);
		625
613	cookie = object->cookie;	626	cookie = object->cookie;
614	set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags);	627	set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags);
615	if (test_and_clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags))	628	if (test_and_clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags))
@@ -629,7 +642,7 @@ static const struct fscache_state fscache_kill_object(struct fscache_object ob · 13 unmodified lines
629	_enter("{OBJ%x,%d,%d},%d",	642	_enter("{OBJ%x,%d,%d},%d",
630	object->debug_id, object->n_ops, object->n_children, event);	643	object->debug_id, object->n_ops, object->n_children, event);
631		644
632	clear_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);	645	fscache_mark_object_dead(object);
633	object->oob_event_mask = 0;	646	object->oob_event_mask = 0;
634		647
635	if (list_empty(&object->dependents) &&	648	if (list_empty(&object->dependents) &&
@@ -948,7 +961,8 @@ static const struct fscache_state *_fscache_invalidate_object(struct fscache_obj · 312 unmodified lines
948	if (!op)	961	if (!op)
949	goto nomem;	962	goto nomem;
950		963
951	fscache_operation_init(op, object->cache->ops->invalidate_object, NULL);	964	fscache_operation_init(op, object->cache->ops->invalidate_object,
		965	NULL, NULL);
952	op->flags = FSCACHE_OP_ASYNC \|	966	op->flags = FSCACHE_OP_ASYNC \|
953	(1 << FSCACHE_OP_EXCLUSIVE) \|	967	(1 << FSCACHE_OP_EXCLUSIVE) \|
954	(1 << FSCACHE_OP_UNUSE_COOKIE);	968	(1 << FSCACHE_OP_UNUSE_COOKIE);
@@ -974,13 +988,13 @@ static const struct fscache_state *_fscache_invalidate_object(struct fscache_obj · 19 unmodified lines
974	return transit_to(UPDATE_OBJECT);	988	return transit_to(UPDATE_OBJECT);
975		989
976	nomem:	990	nomem:
977	clear_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);	991	fscache_mark_object_dead(object);
978	fscache_unuse_cookie(object);	992	fscache_unuse_cookie(object);
979	_leave(" [ENOMEM]");	993	_leave(" [ENOMEM]");
980	return transit_to(KILL_OBJECT);	994	return transit_to(KILL_OBJECT);
981		995
982	submit_op_failed:	996	submit_op_failed:
983	clear_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);	997	fscache_mark_object_dead(object);
984	spin_unlock(&cookie->lock);	998	spin_unlock(&cookie->lock);
985	fscache_unuse_cookie(object);	999	fscache_unuse_cookie(object);
986	kfree(op);	1000	kfree(op);
@@ -1016,3 +1030,50 @@ static const struct fscache_state fscache_update_object(struct fscache_object · 29 unmodified lines
1016	_leave("");	1030	_leave("");
1017	return transit_to(WAIT_FOR_CMD);	1031	return transit_to(WAIT_FOR_CMD);
1018	}	1032	}
		1033
		1034	/**
		1035	* fscache_object_retrying_stale - Note retrying stale object
		1036	* @object: The object that will be retried
		1037	*
		1038	* Note that an object lookup found an on-disk object that was adjudged to be
		1039	* stale and has been deleted. The lookup will be retried.
		1040	*/
		1041	void fscache_object_retrying_stale(struct fscache_object *object)
		1042	{
		1043	fscache_stat(&fscache_n_cache_no_space_reject);
		1044	}
		1045	EXPORT_SYMBOL(fscache_object_retrying_stale);
		1046
		1047	/**
		1048	* fscache_object_mark_killed - Note that an object was killed
		1049	* @object: The object that was culled
		1050	* @why: The reason the object was killed.
		1051	*
		1052	* Note that an object was killed. Returns true if the object was
		1053	* already marked killed, false if it wasn't.
		1054	*/
		1055	void fscache_object_mark_killed(struct fscache_object *object,
		1056	enum fscache_why_object_killed why)
		1057	{
		1058	if (test_and_set_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->flags)) {
		1059	pr_err("Error: Object already killed by cache [%s]\n",
		1060	object->cache->identifier);
		1061	return;
		1062	}
		1063
		1064	switch (why) {
		1065	case FSCACHE_OBJECT_NO_SPACE:
		1066	fscache_stat(&fscache_n_cache_no_space_reject);
		1067	break;
		1068	case FSCACHE_OBJECT_IS_STALE:
		1069	fscache_stat(&fscache_n_cache_stale_objects);
		1070	break;
		1071	case FSCACHE_OBJECT_WAS_RETIRED:
		1072	fscache_stat(&fscache_n_cache_retired_objects);
		1073	break;
		1074	case FSCACHE_OBJECT_WAS_CULLED:
		1075	fscache_stat(&fscache_n_cache_culled_objects);
		1076	break;
		1077	}
		1078	}
		1079	EXPORT_SYMBOL(fscache_object_mark_killed);

fs/fscache/operation.c+168−86

@@ -20,6 +20,35 @@ · 19 unmodified lines
20	atomic_t fscache_op_debug_id;	20	atomic_t fscache_op_debug_id;
21	EXPORT_SYMBOL(fscache_op_debug_id);	21	EXPORT_SYMBOL(fscache_op_debug_id);
22		22
		23	static void fscache_operation_dummy_cancel(struct fscache_operation *op)
		24	{
		25	}
		26
		27	/**
		28	* fscache_operation_init - Do basic initialisation of an operation
		29	* @op: The operation to initialise
		30	* @release: The release function to assign
		31	*
		32	* Do basic initialisation of an operation. The caller must still set flags,
		33	* object and processor if needed.
		34	*/
		35	void fscache_operation_init(struct fscache_operation *op,
		36	fscache_operation_processor_t processor,
		37	fscache_operation_cancel_t cancel,
		38	fscache_operation_release_t release)
		39	{
		40	INIT_WORK(&op->work, fscache_op_work_func);
		41	atomic_set(&op->usage, 1);
		42	op->state = FSCACHE_OP_ST_INITIALISED;
		43	op->debug_id = atomic_inc_return(&fscache_op_debug_id);
		44	op->processor = processor;
		45	op->cancel = cancel ?: fscache_operation_dummy_cancel;
		46	op->release = release;
		47	INIT_LIST_HEAD(&op->pend_link);
		48	fscache_stat(&fscache_n_op_initialised);
		49	}
		50	EXPORT_SYMBOL(fscache_operation_init);
		51
23	/**	52	/**
24	* fscache_enqueue_operation - Enqueue an operation for processing	53	* fscache_enqueue_operation - Enqueue an operation for processing
25	* @op: The operation to enqueue	54	* @op: The operation to enqueue
@@ -75,6 +104,43 @@ static void fscache_run_op(struct fscache_object *object, · 49 unmodified lines
75	fscache_stat(&fscache_n_op_run);	104	fscache_stat(&fscache_n_op_run);
76	}	105	}
77		106
		107	/*
		108	* report an unexpected submission
		109	*/
		110	static void fscache_report_unexpected_submission(struct fscache_object *object,
		111	struct fscache_operation *op,
		112	const struct fscache_state *ostate)
		113	{
		114	static bool once_only;
		115	struct fscache_operation *p;
		116	unsigned n;
		117
		118	if (once_only)
		119	return;
		120	once_only = true;
		121
		122	kdebug("unexpected submission OP%x [OBJ%x %s]",
		123	op->debug_id, object->debug_id, object->state->name);
		124	kdebug("objstate=%s [%s]", object->state->name, ostate->name);
		125	kdebug("objflags=%lx", object->flags);
		126	kdebug("objevent=%lx [%lx]", object->events, object->event_mask);
		127	kdebug("ops=%u inp=%u exc=%u",
		128	object->n_ops, object->n_in_progress, object->n_exclusive);
		129
		130	if (!list_empty(&object->pending_ops)) {
		131	n = 0;
		132	list_for_each_entry(p, &object->pending_ops, pend_link) {
		133	ASSERTCMP(p->object, ==, object);
		134	kdebug("%p %p", op->processor, op->release);
		135	n++;
		136	}
		137
		138	kdebug("n=%u", n);
		139	}
		140
		141	dump_stack();
		142	}
		143
78	/*	144	/*
79	* submit an exclusive operation for an object	145	* submit an exclusive operation for an object
80	* - other ops are excluded from running simultaneously with this one	146	* - other ops are excluded from running simultaneously with this one
@@ -83,6 +149,8 @@ static void fscache_run_op(struct fscache_object *object, · 2 unmodified lines
83	int fscache_submit_exclusive_op(struct fscache_object *object,	149	int fscache_submit_exclusive_op(struct fscache_object *object,
84	struct fscache_operation *op)	150	struct fscache_operation *op)
85	{	151	{
		152	const struct fscache_state *ostate;
		153	unsigned long flags;
86	int ret;	154	int ret;
87		155
88	_enter("{OBJ%x OP%x},", object->debug_id, op->debug_id);	156	_enter("{OBJ%x OP%x},", object->debug_id, op->debug_id);
@@ -95,8 +163,21 @@ int fscache_submit_exclusive_op(struct fscache_object *object, · 6 unmodified lines
95	ASSERTCMP(object->n_ops, >=, object->n_exclusive);	163	ASSERTCMP(object->n_ops, >=, object->n_exclusive);
96	ASSERT(list_empty(&op->pend_link));	164	ASSERT(list_empty(&op->pend_link));
97		165
		166	ostate = object->state;
		167	smp_rmb();
		168
98	op->state = FSCACHE_OP_ST_PENDING;	169	op->state = FSCACHE_OP_ST_PENDING;
99	if (fscache_object_is_active(object)) {	170	flags = READ_ONCE(object->flags);
		171	if (unlikely(!(flags & BIT(FSCACHE_OBJECT_IS_LIVE)))) {
		172	fscache_stat(&fscache_n_op_rejected);
		173	op->cancel(op);
		174	op->state = FSCACHE_OP_ST_CANCELLED;
		175	ret = -ENOBUFS;
		176	} else if (unlikely(fscache_cache_is_broken(object))) {
		177	op->cancel(op);
		178	op->state = FSCACHE_OP_ST_CANCELLED;
		179	ret = -EIO;
		180	} else if (flags & BIT(FSCACHE_OBJECT_IS_AVAILABLE)) {
100	op->object = object;	181	op->object = object;
101	object->n_ops++;	182	object->n_ops++;
102	object->n_exclusive++; /* reads and writes must wait */	183	object->n_exclusive++; /* reads and writes must wait */
@@ -118,7 +199,7 @@ int fscache_submit_exclusive_op(struct fscache_object *object, · 15 unmodified lines
118	/* need to issue a new write op after this */	199	/* need to issue a new write op after this */
119	clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags);	200	clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags);
120	ret = 0;	201	ret = 0;
121	} else if (test_bit(FSCACHE_OBJECT_IS_LOOKED_UP, &object->flags)) {	202	} else if (flags & BIT(FSCACHE_OBJECT_IS_LOOKED_UP)) {
122	op->object = object;	203	op->object = object;
123	object->n_ops++;	204	object->n_ops++;
124	object->n_exclusive++; /* reads and writes must wait */	205	object->n_exclusive++; /* reads and writes must wait */
@@ -126,55 +207,21 @@ int fscache_submit_exclusive_op(struct fscache_object *object, · 1 unmodified line
126	list_add_tail(&op->pend_link, &object->pending_ops);	207	list_add_tail(&op->pend_link, &object->pending_ops);
127	fscache_stat(&fscache_n_op_pend);	208	fscache_stat(&fscache_n_op_pend);
128	ret = 0;	209	ret = 0;
		210	} else if (flags & BIT(FSCACHE_OBJECT_KILLED_BY_CACHE)) {
		211	op->cancel(op);
		212	op->state = FSCACHE_OP_ST_CANCELLED;
		213	ret = -ENOBUFS;
129	} else {	214	} else {
130	/* If we're in any other state, there must have been an I/O	215	fscache_report_unexpected_submission(object, op, ostate);
131	* error of some nature.	216	op->cancel(op);
132	*/	217	op->state = FSCACHE_OP_ST_CANCELLED;
133	ASSERT(test_bit(FSCACHE_IOERROR, &object->cache->flags));	218	ret = -ENOBUFS;
134	ret = -EIO;
135	}	219	}
136		220
137	spin_unlock(&object->lock);	221	spin_unlock(&object->lock);
138	return ret;	222	return ret;
139	}	223	}
140		224
141	/*
142	* report an unexpected submission
143	*/
144	static void fscache_report_unexpected_submission(struct fscache_object *object,
145	struct fscache_operation *op,
146	const struct fscache_state *ostate)
147	{
148	static bool once_only;
149	struct fscache_operation *p;
150	unsigned n;
151
152	if (once_only)
153	return;
154	once_only = true;
155
156	kdebug("unexpected submission OP%x [OBJ%x %s]",
157	op->debug_id, object->debug_id, object->state->name);
158	kdebug("objstate=%s [%s]", object->state->name, ostate->name);
159	kdebug("objflags=%lx", object->flags);
160	kdebug("objevent=%lx [%lx]", object->events, object->event_mask);
161	kdebug("ops=%u inp=%u exc=%u",
162	object->n_ops, object->n_in_progress, object->n_exclusive);
163
164	if (!list_empty(&object->pending_ops)) {
165	n = 0;
166	list_for_each_entry(p, &object->pending_ops, pend_link) {
167	ASSERTCMP(p->object, ==, object);
168	kdebug("%p %p", op->processor, op->release);
169	n++;
170	}
171
172	kdebug("n=%u", n);
173	}
174
175	dump_stack();
176	}
177
178	/*	225	/*
179	* submit an operation for an object	226	* submit an operation for an object
180	* - objects may be submitted only in the following states:	227	* - objects may be submitted only in the following states:
@@ -187,6 +234,7 @@ int fscache_submit_op(struct fscache_object *object, · 6 unmodified lines
187	struct fscache_operation *op)	234	struct fscache_operation *op)
188	{	235	{
189	const struct fscache_state *ostate;	236	const struct fscache_state *ostate;
		237	unsigned long flags;
190	int ret;	238	int ret;
191		239
192	_enter("{OBJ%x OP%x},{%u}",	240	_enter("{OBJ%x OP%x},{%u}",
@@ -204,7 +252,17 @@ int fscache_submit_op(struct fscache_object *object, · 11 unmodified lines
204	smp_rmb();	252	smp_rmb();
205		253
206	op->state = FSCACHE_OP_ST_PENDING;	254	op->state = FSCACHE_OP_ST_PENDING;
207	if (fscache_object_is_active(object)) {	255	flags = READ_ONCE(object->flags);
		256	if (unlikely(!(flags & BIT(FSCACHE_OBJECT_IS_LIVE)))) {
		257	fscache_stat(&fscache_n_op_rejected);
		258	op->cancel(op);
		259	op->state = FSCACHE_OP_ST_CANCELLED;
		260	ret = -ENOBUFS;
		261	} else if (unlikely(fscache_cache_is_broken(object))) {
		262	op->cancel(op);
		263	op->state = FSCACHE_OP_ST_CANCELLED;
		264	ret = -EIO;
		265	} else if (flags & BIT(FSCACHE_OBJECT_IS_AVAILABLE)) {
208	op->object = object;	266	op->object = object;
209	object->n_ops++;	267	object->n_ops++;
210		268
@@ -222,23 +280,21 @@ int fscache_submit_op(struct fscache_object *object, · 11 unmodified lines
222	fscache_run_op(object, op);	280	fscache_run_op(object, op);
223	}	281	}
224	ret = 0;	282	ret = 0;
225	} else if (test_bit(FSCACHE_OBJECT_IS_LOOKED_UP, &object->flags)) {	283	} else if (flags & BIT(FSCACHE_OBJECT_IS_LOOKED_UP)) {
226	op->object = object;	284	op->object = object;
227	object->n_ops++;	285	object->n_ops++;
228	atomic_inc(&op->usage);	286	atomic_inc(&op->usage);
229	list_add_tail(&op->pend_link, &object->pending_ops);	287	list_add_tail(&op->pend_link, &object->pending_ops);
230	fscache_stat(&fscache_n_op_pend);	288	fscache_stat(&fscache_n_op_pend);
231	ret = 0;	289	ret = 0;
232	} else if (fscache_object_is_dying(object)) {	290	} else if (flags & BIT(FSCACHE_OBJECT_KILLED_BY_CACHE)) {
233	fscache_stat(&fscache_n_op_rejected);	291	op->cancel(op);
234	op->state = FSCACHE_OP_ST_CANCELLED;	292	op->state = FSCACHE_OP_ST_CANCELLED;
235	ret = -ENOBUFS;	293	ret = -ENOBUFS;
236	} else if (!test_bit(FSCACHE_IOERROR, &object->cache->flags)) {	294	} else {
237	fscache_report_unexpected_submission(object, op, ostate);	295	fscache_report_unexpected_submission(object, op, ostate);
238	ASSERT(!fscache_object_is_active(object));	296	ASSERT(!fscache_object_is_active(object));
239	op->state = FSCACHE_OP_ST_CANCELLED;	297	op->cancel(op);
240	ret = -ENOBUFS;
241	} else {
242	op->state = FSCACHE_OP_ST_CANCELLED;	298	op->state = FSCACHE_OP_ST_CANCELLED;
243	ret = -ENOBUFS;	299	ret = -ENOBUFS;
244	}	300	}
@@ -293,9 +349,10 @@ void fscache_start_operations(struct fscache_object *object) · 48 unmodified lines
293	* cancel an operation that's pending on an object	349	* cancel an operation that's pending on an object
294	*/	350	*/
295	int fscache_cancel_op(struct fscache_operation *op,	351	int fscache_cancel_op(struct fscache_operation *op,
296	void (do_cancel)(struct fscache_operation ))	352	bool cancel_in_progress_op)
297	{	353	{
298	struct fscache_object *object = op->object;	354	struct fscache_object *object = op->object;
		355	bool put = false;
299	int ret;	356	int ret;
300		357
301	_enter("OBJ%x OP%x}", op->object->debug_id, op->debug_id);	358	_enter("OBJ%x OP%x}", op->object->debug_id, op->debug_id);
@@ -309,19 +366,37 @@ int fscache_cancel_op(struct fscache_operation *op, · 7 unmodified lines
309	ret = -EBUSY;	366	ret = -EBUSY;
310	if (op->state == FSCACHE_OP_ST_PENDING) {	367	if (op->state == FSCACHE_OP_ST_PENDING) {
311	ASSERT(!list_empty(&op->pend_link));	368	ASSERT(!list_empty(&op->pend_link));
312	fscache_stat(&fscache_n_op_cancelled);
313	list_del_init(&op->pend_link);	369	list_del_init(&op->pend_link);
314	if (do_cancel)	370	put = true;
315	do_cancel(op);	371
		372	fscache_stat(&fscache_n_op_cancelled);
		373	op->cancel(op);
		374	op->state = FSCACHE_OP_ST_CANCELLED;
		375	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))
		376	object->n_exclusive--;
		377	if (test_and_clear_bit(FSCACHE_OP_WAITING, &op->flags))
		378	wake_up_bit(&op->flags, FSCACHE_OP_WAITING);
		379	ret = 0;
		380	} else if (op->state == FSCACHE_OP_ST_IN_PROGRESS && cancel_in_progress_op) {
		381	ASSERTCMP(object->n_in_progress, >, 0);
		382	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))
		383	object->n_exclusive--;
		384	object->n_in_progress--;
		385	if (object->n_in_progress == 0)
		386	fscache_start_operations(object);
		387
		388	fscache_stat(&fscache_n_op_cancelled);
		389	op->cancel(op);
316	op->state = FSCACHE_OP_ST_CANCELLED;	390	op->state = FSCACHE_OP_ST_CANCELLED;
317	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))	391	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))
318	object->n_exclusive--;	392	object->n_exclusive--;
319	if (test_and_clear_bit(FSCACHE_OP_WAITING, &op->flags))	393	if (test_and_clear_bit(FSCACHE_OP_WAITING, &op->flags))
320	wake_up_bit(&op->flags, FSCACHE_OP_WAITING);	394	wake_up_bit(&op->flags, FSCACHE_OP_WAITING);
321	fscache_put_operation(op);
322	ret = 0;	395	ret = 0;
323	}	396	}
324		397
		398	if (put)
		399	fscache_put_operation(op);
325	spin_unlock(&object->lock);	400	spin_unlock(&object->lock);
326	_leave(" = %d", ret);	401	_leave(" = %d", ret);
327	return ret;	402	return ret;
@@ -345,6 +420,7 @@ void fscache_cancel_all_ops(struct fscache_object *object) · 17 unmodified lines
345	list_del_init(&op->pend_link);	420	list_del_init(&op->pend_link);
346		421
347	ASSERTCMP(op->state, ==, FSCACHE_OP_ST_PENDING);	422	ASSERTCMP(op->state, ==, FSCACHE_OP_ST_PENDING);
		423	op->cancel(op);
348	op->state = FSCACHE_OP_ST_CANCELLED;	424	op->state = FSCACHE_OP_ST_CANCELLED;
349		425
350	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))	426	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))
@@ -377,8 +453,12 @@ void fscache_op_complete(struct fscache_operation *op, bool cancelled) · 26 unmodified lines
377		453
378	spin_lock(&object->lock);	454	spin_lock(&object->lock);
379		455
380	op->state = cancelled ?	456	if (!cancelled) {
381	FSCACHE_OP_ST_CANCELLED : FSCACHE_OP_ST_COMPLETE;	457	op->state = FSCACHE_OP_ST_COMPLETE;
		458	} else {
		459	op->cancel(op);
		460	op->state = FSCACHE_OP_ST_CANCELLED;
		461	}
382		462
383	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))	463	if (test_bit(FSCACHE_OP_EXCLUSIVE, &op->flags))
384	object->n_exclusive--;	464	object->n_exclusive--;
@@ -409,9 +489,9 @@ void fscache_put_operation(struct fscache_operation *op) · 24 unmodified lines
409	return;	489	return;
410		490
411	_debug("PUT OP");	491	_debug("PUT OP");
412	ASSERTIFCMP(op->state != FSCACHE_OP_ST_COMPLETE,	492	ASSERTIFCMP(op->state != FSCACHE_OP_ST_INITIALISED &&
		493	op->state != FSCACHE_OP_ST_COMPLETE,
413	op->state, ==, FSCACHE_OP_ST_CANCELLED);	494	op->state, ==, FSCACHE_OP_ST_CANCELLED);
414	op->state = FSCACHE_OP_ST_DEAD;
415		495
416	fscache_stat(&fscache_n_op_release);	496	fscache_stat(&fscache_n_op_release);
417		497
@@ -419,37 +499,39 @@ void fscache_put_operation(struct fscache_operation *op) · 1 unmodified line
419	op->release(op);	499	op->release(op);
420	op->release = NULL;	500	op->release = NULL;
421	}	501	}
		502	op->state = FSCACHE_OP_ST_DEAD;
422		503
423	object = op->object;	504	object = op->object;
		505	if (likely(object)) {
		506	if (test_bit(FSCACHE_OP_DEC_READ_CNT, &op->flags))
		507	atomic_dec(&object->n_reads);
		508	if (test_bit(FSCACHE_OP_UNUSE_COOKIE, &op->flags))
		509	fscache_unuse_cookie(object);
		510
		511	/* now... we may get called with the object spinlock held, so we
		512	* complete the cleanup here only if we can immediately acquire the
		513	* lock, and defer it otherwise */
		514	if (!spin_trylock(&object->lock)) {
		515	_debug("defer put");
		516	fscache_stat(&fscache_n_op_deferred_release);
		517
		518	cache = object->cache;
		519	spin_lock(&cache->op_gc_list_lock);
		520	list_add_tail(&op->pend_link, &cache->op_gc_list);
		521	spin_unlock(&cache->op_gc_list_lock);
		522	schedule_work(&cache->op_gc);
		523	_leave(" [defer]");
		524	return;
		525	}
424		526
425	if (test_bit(FSCACHE_OP_DEC_READ_CNT, &op->flags))	527	ASSERTCMP(object->n_ops, >, 0);
426	atomic_dec(&object->n_reads);	528	object->n_ops--;
427	if (test_bit(FSCACHE_OP_UNUSE_COOKIE, &op->flags))	529	if (object->n_ops == 0)
428	fscache_unuse_cookie(object);	530	fscache_raise_event(object, FSCACHE_OBJECT_EV_CLEARED);
429
430	/* now... we may get called with the object spinlock held, so we
431	* complete the cleanup here only if we can immediately acquire the
432	* lock, and defer it otherwise */
433	if (!spin_trylock(&object->lock)) {
434	_debug("defer put");
435	fscache_stat(&fscache_n_op_deferred_release);
436		531
437	cache = object->cache;	532	spin_unlock(&object->lock);
438	spin_lock(&cache->op_gc_list_lock);
439	list_add_tail(&op->pend_link, &cache->op_gc_list);
440	spin_unlock(&cache->op_gc_list_lock);
441	schedule_work(&cache->op_gc);
442	_leave(" [defer]");
443	return;
444	}	533	}
445		534
446	ASSERTCMP(object->n_ops, >, 0);
447	object->n_ops--;
448	if (object->n_ops == 0)
449	fscache_raise_event(object, FSCACHE_OBJECT_EV_CLEARED);
450
451	spin_unlock(&object->lock);
452
453	kfree(op);	535	kfree(op);
454	_leave(" [done]");	536	_leave(" [done]");
455	}	537	}

fs/fscache/page.c+43−43

 		return -ENOMEM;
 	}
-	fscache_operation_init(op, fscache_attr_changed_op, NULL);
+	fscache_operation_init(op, fscache_attr_changed_op, NULL, NULL);
 	op->flags = FSCACHE_OP_ASYNC |
 		(1 << FSCACHE_OP_EXCLUSIVE) |
 		(1 << FSCACHE_OP_UNUSE_COOKIE);
 	wake_cookie = __fscache_unuse_cookie(cookie);
 nobufs:
 	spin_unlock(&cookie->lock);
-	kfree(op);
+	fscache_put_operation(op);
 	if (wake_cookie)
 		__fscache_wake_unused_cookie(cookie);
 	fscache_stat(&fscache_n_attr_changed_nobufs);
 }
 EXPORT_SYMBOL(__fscache_attr_changed);
+/*
+ * Handle cancellation of a pending retrieval op
+ */
+static void fscache_do_cancel_retrieval(struct fscache_operation *_op)
+{
+	struct fscache_retrieval *op =
+		container_of(_op, struct fscache_retrieval, op);
+	atomic_set(&op->n_pages, 0);
+}
 /*
  * release a retrieval op reference
  */
 	_enter("{OP%x}", op->op.debug_id);
-	ASSERTCMP(atomic_read(&op->n_pages), ==, 0);
+	ASSERTIFCMP(op->op.state != FSCACHE_OP_ST_INITIALISED,
+		    atomic_read(&op->n_pages), ==, 0);
 	fscache_hist(fscache_retrieval_histogram, op->start_time);
 	if (op->context)
-		fscache_put_context(op->op.object->cookie, op->context);
+		fscache_put_context(op->cookie, op->context);
 	_leave("");
 }
 		return NULL;
 	}
-	fscache_operation_init(&op->op, NULL, fscache_release_retrieval_op);
+	fscache_operation_init(&op->op, NULL,
+			       fscache_do_cancel_retrieval,
+			       fscache_release_retrieval_op);
 	op->op.flags	= FSCACHE_OP_MYTHREAD |
 		(1UL << FSCACHE_OP_WAITING) |
 		(1UL << FSCACHE_OP_UNUSE_COOKIE);
+	op->cookie	= cookie;
 	op->mapping	= mapping;
 	op->end_io_func	= end_io_func;
 	op->context	= context;
 	op->start_time	= jiffies;
 	INIT_LIST_HEAD(&op->to_do);
+	/* Pin the netfs read context in case we need to do the actual netfs
+	 * read because we've encountered a cache read failure.
+	 */
+	if (context)
+		fscache_get_context(op->cookie, context);
 	return op;
 }
 	return 0;
 }
-/*
- * Handle cancellation of a pending retrieval op
- */
-static void fscache_do_cancel_retrieval(struct fscache_operation *_op)
-{
-	struct fscache_retrieval *op =
-		container_of(_op, struct fscache_retrieval, op);
-	atomic_set(&op->n_pages, 0);
-}
 /*
  * wait for an object to become active (or dead)
  */
 int fscache_wait_for_operation_activation(struct fscache_object *object,
 					  struct fscache_operation *op,
 					  atomic_t *stat_op_waits,
-					  atomic_t *stat_object_dead,
+					  atomic_t *stat_object_dead)
-					  void (*do_cancel)(struct fscache_operation *))
 {
 	int ret;
 		fscache_stat(stat_op_waits);
 	if (wait_on_bit(&op->flags, FSCACHE_OP_WAITING,
 			TASK_INTERRUPTIBLE) != 0) {
-		ret = fscache_cancel_op(op, do_cancel);
+		ret = fscache_cancel_op(op, false);
 		if (ret == 0)
 			return -ERESTARTSYS;
 		_leave(" = -ENOBUFS [cancelled]");
 		return -ENOBUFS;
 	}
-	if (unlikely(fscache_object_is_dead(object))) {
+	if (unlikely(fscache_object_is_dying(object) ||
-		pr_err("%s() = -ENOBUFS [obj dead %d]\n", __func__, op->state);
+		     fscache_cache_is_broken(object))) {
-		fscache_cancel_op(op, do_cancel);
+		enum fscache_operation_state state = op->state;
+		fscache_cancel_op(op, true);
 		if (stat_object_dead)
 			fscache_stat(stat_object_dead);
+		_leave(" = -ENOBUFS [obj dead %d]", state);
 		return -ENOBUFS;
 	}
 	return 0;
 	fscache_stat(&fscache_n_retrieval_ops);
-	/* pin the netfs read context in case we need to do the actual netfs
-	 * read because we've encountered a cache read failure */
-	fscache_get_context(object->cookie, op->context);
 	/* we wait for the operation to become active, and then process it
 	 * *here*, in this thread, and not in the thread pool */
 	ret = fscache_wait_for_operation_activation(
 		object, &op->op,
 		__fscache_stat(&fscache_n_retrieval_op_waits),
-		__fscache_stat(&fscache_n_retrievals_object_dead),
+		__fscache_stat(&fscache_n_retrievals_object_dead));
-		fscache_do_cancel_retrieval);
 	if (ret < 0)
 		goto error;
 	spin_unlock(&cookie->lock);
 	if (wake_cookie)
 		__fscache_wake_unused_cookie(cookie);
-	kfree(op);
+	fscache_put_retrieval(op);
 nobufs:
 	fscache_stat(&fscache_n_retrievals_nobufs);
 	_leave(" = -ENOBUFS");
 	fscache_stat(&fscache_n_retrieval_ops);
-	/* pin the netfs read context in case we need to do the actual netfs
-	 * read because we've encountered a cache read failure */
-	fscache_get_context(object->cookie, op->context);
 	/* we wait for the operation to become active, and then process it
 	 * *here*, in this thread, and not in the thread pool */
 	ret = fscache_wait_for_operation_activation(
 		object, &op->op,
 		__fscache_stat(&fscache_n_retrieval_op_waits),
-		__fscache_stat(&fscache_n_retrievals_object_dead),
+		__fscache_stat(&fscache_n_retrievals_object_dead));
-		fscache_do_cancel_retrieval);
 	if (ret < 0)
 		goto error;
 	wake_cookie = __fscache_unuse_cookie(cookie);
 nobufs_unlock:
 	spin_unlock(&cookie->lock);
-	kfree(op);
+	fscache_put_retrieval(op);
 	if (wake_cookie)
 		__fscache_wake_unused_cookie(cookie);
 nobufs:
 	ret = fscache_wait_for_operation_activation(
 		object, &op->op,
 		__fscache_stat(&fscache_n_alloc_op_waits),
-		__fscache_stat(&fscache_n_allocs_object_dead),
+		__fscache_stat(&fscache_n_allocs_object_dead));
-		fscache_do_cancel_retrieval);
 	if (ret < 0)
 		goto error;
 	wake_cookie = __fscache_unuse_cookie(cookie);
 nobufs_unlock:
 	spin_unlock(&cookie->lock);
-	kfree(op);
+	fscache_put_retrieval(op);
 	if (wake_cookie)
 		__fscache_wake_unused_cookie(cookie);
 nobufs:
 	if (!op)
 		goto nomem;
-	fscache_operation_init(&op->op, fscache_write_op,
+	fscache_operation_init(&op->op, fscache_write_op, NULL,
 			       fscache_release_write_op);
 	op->op.flags = FSCACHE_OP_ASYNC |
 		(1 << FSCACHE_OP_WAITING) |
 	spin_unlock(&object->lock);
 	spin_unlock(&cookie->lock);
 	radix_tree_preload_end();
-	kfree(op);
+	fscache_put_operation(&op->op);
 	fscache_stat(&fscache_n_stores_ok);
 	_leave(" = 0");
 	return 0;
 nobufs:
 	spin_unlock(&cookie->lock);
 	radix_tree_preload_end();
-	kfree(op);
+	fscache_put_operation(&op->op);
 	if (wake_cookie)
 		__fscache_wake_unused_cookie(cookie);
 	fscache_stat(&fscache_n_stores_nobufs);
 	return -ENOBUFS;
 nomem_free:
-	kfree(op);
+	fscache_put_operation(&op->op);
 nomem:
 	fscache_stat(&fscache_n_stores_oom);
 	_leave(" = -ENOMEM");

fs/fscache/stats.c+13−1

 atomic_t fscache_n_op_enqueue;
 atomic_t fscache_n_op_requeue;
 atomic_t fscache_n_op_deferred_release;
+atomic_t fscache_n_op_initialised;
 atomic_t fscache_n_op_release;
 atomic_t fscache_n_op_gc;
 atomic_t fscache_n_op_cancelled;
 atomic_t fscache_n_cop_uncache_page;
 atomic_t fscache_n_cop_dissociate_pages;
+atomic_t fscache_n_cache_no_space_reject;
+atomic_t fscache_n_cache_stale_objects;
+atomic_t fscache_n_cache_retired_objects;
+atomic_t fscache_n_cache_culled_objects;
 /*
  * display the general statistics
  */
 		   atomic_read(&fscache_n_op_enqueue),
 		   atomic_read(&fscache_n_op_cancelled),
 		   atomic_read(&fscache_n_op_rejected));
-	seq_printf(m, "Ops    : dfr=%u rel=%u gc=%u\n",
+	seq_printf(m, "Ops    : ini=%u dfr=%u rel=%u gc=%u\n",
+		   atomic_read(&fscache_n_op_initialised),
 		   atomic_read(&fscache_n_op_deferred_release),
 		   atomic_read(&fscache_n_op_release),
 		   atomic_read(&fscache_n_op_gc));
 		   atomic_read(&fscache_n_cop_write_page),
 		   atomic_read(&fscache_n_cop_uncache_page),
 		   atomic_read(&fscache_n_cop_dissociate_pages));
+	seq_printf(m, "CacheEv: nsp=%d stl=%d rtr=%d cul=%d\n",
+		   atomic_read(&fscache_n_cache_no_space_reject),
+		   atomic_read(&fscache_n_cache_stale_objects),
+		   atomic_read(&fscache_n_cache_retired_objects),
+		   atomic_read(&fscache_n_cache_culled_objects));
 	return 0;
 }

fs/fuse/file.c+1−1

@@ -1169,7 +1169,7 @@ static ssize_t fuse_file_write_iter(struct kiocb iocb, struct iov_iter from) · 1168 unmodified lines
1169	if (err <= 0)	1169	if (err <= 0)
1170	goto out;	1170	goto out;
1171		1171
1172	err = file_remove_suid(file);	1172	err = file_remove_privs(file);
1173	if (err)	1173	if (err)
1174	goto out;	1174	goto out;
1175		1175

fs/hfs/hfs_fs.h+1−1

@@ -252,7 +252,7 @@ extern void hfs_mark_mdb_dirty(struct super_block *sb); · 251 unmodified lines
252	#define __hfs_u_to_mtime(sec) cpu_to_be32(sec + 2082844800U - sys_tz.tz_minuteswest * 60)	252	#define __hfs_u_to_mtime(sec) cpu_to_be32(sec + 2082844800U - sys_tz.tz_minuteswest * 60)
253	#define __hfs_m_to_utime(sec) (be32_to_cpu(sec) - 2082844800U + sys_tz.tz_minuteswest * 60)	253	#define __hfs_m_to_utime(sec) (be32_to_cpu(sec) - 2082844800U + sys_tz.tz_minuteswest * 60)
254		254
255	#define HFS_I(inode) (list_entry(inode, struct hfs_inode_info, vfs_inode))	255	#define HFS_I(inode) (container_of(inode, struct hfs_inode_info, vfs_inode))
256	#define HFS_SB(sb) ((struct hfs_sb_info *)(sb)->s_fs_info)	256	#define HFS_SB(sb) ((struct hfs_sb_info *)(sb)->s_fs_info)
257		257
258	#define hfs_m_to_utime(time) (struct timespec){ .tv_sec = __hfs_m_to_utime(time) }	258	#define hfs_m_to_utime(time) (struct timespec){ .tv_sec = __hfs_m_to_utime(time) }

fs/hfsplus/hfsplus_fs.h+1−1

@@ -263,7 +263,7 @@ struct hfsplus_inode_info { · 262 unmodified lines
263		263
264	static inline struct hfsplus_inode_info HFSPLUS_I(struct inode inode)	264	static inline struct hfsplus_inode_info HFSPLUS_I(struct inode inode)
265	{	265	{
266	return list_entry(inode, struct hfsplus_inode_info, vfs_inode);	266	return container_of(inode, struct hfsplus_inode_info, vfs_inode);
267	}	267	}
268		268
269	/*	269	/*

fs/hpfs/hpfs_fn.h+1−1

@@ -304,7 +304,7 @@ extern const struct address_space_operations hpfs_symlink_aops; · 303 unmodified lines
304		304
305	static inline struct hpfs_inode_info hpfs_i(struct inode inode)	305	static inline struct hpfs_inode_info hpfs_i(struct inode inode)
306	{	306	{
307	return list_entry(inode, struct hpfs_inode_info, vfs_inode);	307	return container_of(inode, struct hpfs_inode_info, vfs_inode);
308	}	308	}
309		309
310	static inline struct hpfs_sb_info hpfs_sb(struct super_block sb)	310	static inline struct hpfs_sb_info hpfs_sb(struct super_block sb)

fs/inode.c+46−20

@@ -841,7 +841,11 @@ unsigned int get_next_ino(void) · 840 unmodified lines
841	}	841	}
842	#endif	842	#endif
843		843
844	*p = ++res;	844	res++;
		845	/* get_next_ino should not provide a 0 inode number */
		846	if (unlikely(!res))
		847	res++;
		848	*p = res;
845	put_cpu_var(last_ino);	849	put_cpu_var(last_ino);
846	return res;	850	return res;
847	}	851	}
@@ -1674,7 +1678,31 @@ int should_remove_suid(struct dentry *dentry) · 826 unmodified lines
1674	}	1678	}
1675	EXPORT_SYMBOL(should_remove_suid);	1679	EXPORT_SYMBOL(should_remove_suid);
1676		1680
1677	static int __remove_suid(struct dentry *dentry, int kill)	1681	/*
		1682	* Return mask of changes for notify_change() that need to be done as a
		1683	* response to write or truncate. Return 0 if nothing has to be changed.
		1684	* Negative value on error (change should be denied).
		1685	*/
		1686	int dentry_needs_remove_privs(struct dentry *dentry)
		1687	{
		1688	struct inode *inode = d_inode(dentry);
		1689	int mask = 0;
		1690	int ret;
		1691
		1692	if (IS_NOSEC(inode))
		1693	return 0;
		1694
		1695	mask = should_remove_suid(dentry);
		1696	ret = security_inode_need_killpriv(dentry);
		1697	if (ret < 0)
		1698	return ret;
		1699	if (ret)
		1700	mask \|= ATTR_KILL_PRIV;
		1701	return mask;
		1702	}
		1703	EXPORT_SYMBOL(dentry_needs_remove_privs);
		1704
		1705	static int __remove_privs(struct dentry *dentry, int kill)
1678	{	1706	{
1679	struct iattr newattrs;	1707	struct iattr newattrs;
1680		1708
@@ -1686,33 +1714,32 @@ static int __remove_suid(struct dentry *dentry, int kill) · 5 unmodified lines
1686	return notify_change(dentry, &newattrs, NULL);	1714	return notify_change(dentry, &newattrs, NULL);
1687	}	1715	}
1688		1716
1689	int file_remove_suid(struct file *file)	1717	/*
		1718	* Remove special file priviledges (suid, capabilities) when file is written
		1719	* to or truncated.
		1720	*/
		1721	int file_remove_privs(struct file *file)
1690	{	1722	{
1691	struct dentry *dentry = file->f_path.dentry;	1723	struct dentry *dentry = file->f_path.dentry;
1692	struct inode *inode = d_inode(dentry);	1724	struct inode *inode = d_inode(dentry);
1693	int killsuid;	1725	int kill;
1694	int killpriv;
1695	int error = 0;	1726	int error = 0;
1696		1727
1697	/* Fast path for nothing security related */	1728	/* Fast path for nothing security related */
1698	if (IS_NOSEC(inode))	1729	if (IS_NOSEC(inode))
1699	return 0;	1730	return 0;
1700		1731
1701	killsuid = should_remove_suid(dentry);	1732	kill = file_needs_remove_privs(file);
1702	killpriv = security_inode_need_killpriv(dentry);	1733	if (kill < 0)
1703		1734	return kill;
1704	if (killpriv < 0)	1735	if (kill)
1705	return killpriv;	1736	error = __remove_privs(dentry, kill);
1706	if (killpriv)	1737	if (!error)
1707	error = security_inode_killpriv(dentry);	1738	inode_has_no_xattr(inode);
1708	if (!error && killsuid)
1709	error = __remove_suid(dentry, killsuid);
1710	if (!error && (inode->i_sb->s_flags & MS_NOSEC))
1711	inode->i_flags \|= S_NOSEC;
1712		1739
1713	return error;	1740	return error;
1714	}	1741	}
1715	EXPORT_SYMBOL(file_remove_suid);	1742	EXPORT_SYMBOL(file_remove_privs);
1716		1743
1717	/**	1744	/**
1718	* file_update_time - update mtime and ctime time	1745	* file_update_time - update mtime and ctime time
@@ -1967,9 +1994,8 @@ EXPORT_SYMBOL(inode_dio_wait); · 248 unmodified lines
1967	* inode is being instantiated). The reason for the cmpxchg() loop	1994	* inode is being instantiated). The reason for the cmpxchg() loop
1968	* --- which wouldn't be necessary if all code paths which modify	1995	* --- which wouldn't be necessary if all code paths which modify
1969	* i_flags actually followed this rule, is that there is at least one	1996	* i_flags actually followed this rule, is that there is at least one
1970	* code path which doesn't today --- for example,	1997	* code path which doesn't today so we use cmpxchg() out of an abundance
1971	* __generic_file_aio_write() calls file_remove_suid() without holding	1998	* of caution.
1972	* i_mutex --- so we use cmpxchg() out of an abundance of caution.
1973	*	1999	*
1974	* In the long run, i_mutex is overkill, and we should probably look	2000	* In the long run, i_mutex is overkill, and we should probably look
1975	* at using the i_lock spinlock to protect i_flags, and then make sure	2001	* at using the i_lock spinlock to protect i_flags, and then make sure

fs/internal.h+1−0

@@ -107,6 +107,7 @@ extern struct file do_file_open_root(struct dentry , struct vfsmount *, · 106 unmodified lines
107	extern long do_handle_open(int mountdirfd,	107	extern long do_handle_open(int mountdirfd,
108	struct file_handle __user *ufh, int open_flag);	108	struct file_handle __user *ufh, int open_flag);
109	extern int open_check_o_direct(struct file *f);	109	extern int open_check_o_direct(struct file *f);
		110	extern int vfs_open(const struct path , struct file , const struct cred *);
110		111
111	/*	112	/*
112	* inode.c	113	* inode.c

fs/jffs2/os-linux.h+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	struct kstatfs;	19	struct kstatfs;
20	struct kvec;	20	struct kvec;
21		21
22	#define JFFS2_INODE_INFO(i) (list_entry(i, struct jffs2_inode_info, vfs_inode))	22	#define JFFS2_INODE_INFO(i) (container_of(i, struct jffs2_inode_info, vfs_inode))
23	#define OFNI_EDONI_2SFFJ(f) (&(f)->vfs_inode)	23	#define OFNI_EDONI_2SFFJ(f) (&(f)->vfs_inode)
24	#define JFFS2_SB_INFO(sb) (sb->s_fs_info)	24	#define JFFS2_SB_INFO(sb) (sb->s_fs_info)
25	#define OFNI_BS_2SFFJ(c) ((struct super_block *)c->os_priv)	25	#define OFNI_BS_2SFFJ(c) ((struct super_block *)c->os_priv)

fs/jfs/jfs_incore.h+1−1

@@ -206,7 +206,7 @@ struct jfs_sb_info { · 205 unmodified lines
206		206
207	static inline struct jfs_inode_info JFS_IP(struct inode inode)	207	static inline struct jfs_inode_info JFS_IP(struct inode inode)
208	{	208	{
209	return list_entry(inode, struct jfs_inode_info, vfs_inode);	209	return container_of(inode, struct jfs_inode_info, vfs_inode);
210	}	210	}
211		211
212	static inline int jfs_dirtable_inline(struct inode *inode)	212	static inline int jfs_dirtable_inline(struct inode *inode)

fs/libfs.c+0−5

 #include "internal.h"
-static inline int simple_positive(struct dentry *dentry)
-{
-	return d_really_is_positive(dentry) && !d_unhashed(dentry);
-}
 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		   struct kstat *stat)
 {

fs/minix/dir.c+0−5

 	return last_byte;
 }
-static inline unsigned long dir_pages(struct inode *inode)
-{
-	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
-}
 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
 {
 	struct address_space *mapping = page->mapping;

fs/minix/minix.h+1−1

@@ -84,7 +84,7 @@ static inline struct minix_sb_info minix_sb(struct super_block sb) · 83 unmodified lines
84		84
85	static inline struct minix_inode_info minix_i(struct inode inode)	85	static inline struct minix_inode_info minix_i(struct inode inode)
86	{	86	{
87	return list_entry(inode, struct minix_inode_info, vfs_inode);	87	return container_of(inode, struct minix_inode_info, vfs_inode);
88	}	88	}
89		89
90	static inline unsigned minix_blocks_needed(unsigned bits, unsigned blocksize)	90	static inline unsigned minix_blocks_needed(unsigned bits, unsigned blocksize)

fs/namei.c+3−3

 	get_fs_root(current->fs, &nd->root);
 }
-static unsigned set_root_rcu(struct nameidata *nd)
+static void set_root_rcu(struct nameidata *nd)
 {
 	struct fs_struct *fs = current->fs;
 	unsigned seq;
 		nd->root = fs->root;
 		nd->root_seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
 	} while (read_seqcount_retry(&fs->seq, seq));
-	return nd->root_seq;
 }
 static void path_put_conditional(struct path *path, struct nameidata *nd)
 	if (*s == '/') {
 		if (flags & LOOKUP_RCU) {
 			rcu_read_lock();
-			nd->seq = set_root_rcu(nd);
+			set_root_rcu(nd);
+			nd->seq = nd->root_seq;
 		} else {
 			set_root(nd);
 			path_get(&nd->root);

fs/ncpfs/dir.c+2−0

 		case 0x00:
 			ncp_dbg(1, "renamed %pd -> %pd\n",
 				old_dentry, new_dentry);
+			ncp_d_prune(old_dentry);
+			ncp_d_prune(new_dentry);
 			break;
 		case 0x9E:
 			error = -ENAMETOOLONG;

fs/nfs/dir.c+1−1

@@ -1768,7 +1768,7 @@ EXPORT_SYMBOL_GPL(nfs_mkdir); · 1767 unmodified lines
1768		1768
1769	static void nfs_dentry_handle_enoent(struct dentry *dentry)	1769	static void nfs_dentry_handle_enoent(struct dentry *dentry)
1770	{	1770	{
1771	if (d_really_is_positive(dentry) && !d_unhashed(dentry))	1771	if (simple_positive(dentry))
1772	d_delete(dentry);	1772	d_delete(dentry);
1773	}	1773	}
1774		1774

fs/nilfs2/dir.c+0−5

 	page_cache_release(page);
 }
-static inline unsigned long dir_pages(struct inode *inode)
-{
-	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
-}
 /*
  * Return the offset into page `page_nr' of the last valid
  * byte in that page, plus one.

fs/nilfs2/inode.c+2−20

@@ -307,31 +307,13 @@ static int nilfs_write_end(struct file file, struct address_space mapping, · 306 unmodified lines
307	static ssize_t	307	static ssize_t
308	nilfs_direct_IO(struct kiocb iocb, struct iov_iter iter, loff_t offset)	308	nilfs_direct_IO(struct kiocb iocb, struct iov_iter iter, loff_t offset)
309	{	309	{
310	struct file *file = iocb->ki_filp;	310	struct inode *inode = file_inode(iocb->ki_filp);
311	struct address_space *mapping = file->f_mapping;
312	struct inode *inode = file->f_mapping->host;
313	size_t count = iov_iter_count(iter);
314	ssize_t size;
315		311
316	if (iov_iter_rw(iter) == WRITE)	312	if (iov_iter_rw(iter) == WRITE)
317	return 0;	313	return 0;
318		314
319	/* Needs synchronization with the cleaner */	315	/* Needs synchronization with the cleaner */
320	size = blockdev_direct_IO(iocb, inode, iter, offset, nilfs_get_block);	316	return blockdev_direct_IO(iocb, inode, iter, offset, nilfs_get_block);
321
322	/*
323	* In case of error extending write may have instantiated a few
324	* blocks outside i_size. Trim these off again.
325	*/
326	if (unlikely(iov_iter_rw(iter) == WRITE && size < 0)) {
327	loff_t isize = i_size_read(inode);
328	loff_t end = offset + count;
329
330	if (end > isize)
331	nilfs_write_failed(mapping, end);
332	}
333
334	return size;
335	}	317	}
336		318
337	const struct address_space_operations nilfs_aops = {	319	const struct address_space_operations nilfs_aops = {

fs/ntfs/file.c+1−1

@@ -382,7 +382,7 @@ static ssize_t ntfs_prepare_file_for_write(struct kiocb *iocb, · 381 unmodified lines
382	base_ni = ni;	382	base_ni = ni;
383	if (NInoAttr(ni))	383	if (NInoAttr(ni))
384	base_ni = ni->ext.base_ntfs_ino;	384	base_ni = ni->ext.base_ntfs_ino;
385	err = file_remove_suid(file);	385	err = file_remove_privs(file);
386	if (unlikely(err))	386	if (unlikely(err))
387	goto out;	387	goto out;
388	/*	388	/*

fs/ntfs/inode.h+1−1

@@ -239,7 +239,7 @@ typedef struct { · 238 unmodified lines
239	*/	239	*/
240	static inline ntfs_inode NTFS_I(struct inode inode)	240	static inline ntfs_inode NTFS_I(struct inode inode)
241	{	241	{
242	return (ntfs_inode *)list_entry(inode, big_ntfs_inode, vfs_inode);	242	return (ntfs_inode *)container_of(inode, big_ntfs_inode, vfs_inode);
243	}	243	}
244		244
245	static inline struct inode VFS_I(ntfs_inode ni)	245	static inline struct inode VFS_I(ntfs_inode ni)

fs/open.c+36−25

 		newattrs.ia_valid |= ATTR_FILE;
 	}
-	/* Remove suid/sgid on truncate too */
+	/* Remove suid, sgid, and file capabilities on truncate too */
-	ret = should_remove_suid(dentry);
+	ret = dentry_needs_remove_privs(dentry);
+	if (ret < 0)
+		return ret;
 	if (ret)
 		newattrs.ia_valid |= ret | ATTR_FORCE;
 }
 static int do_dentry_open(struct file *f,
+			  struct inode *inode,
 			  int (*open)(struct inode *, struct file *),
 			  const struct cred *cred)
 {
 	static const struct file_operations empty_fops = {};
-	struct inode *inode;
 	int error;
 	f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
 				FMODE_PREAD | FMODE_PWRITE;
 	path_get(&f->f_path);
-	inode = f->f_inode = f->f_path.dentry->d_inode;
+	f->f_inode = inode;
 	f->f_mapping = inode->i_mapping;
 	if (unlikely(f->f_flags & O_PATH)) {
 	BUG_ON(*opened & FILE_OPENED); /* once it's opened, it's opened */
 	file->f_path.dentry = dentry;
-	error = do_dentry_open(file, open, current_cred());
+	error = do_dentry_open(file, d_backing_inode(dentry), open,
+			       current_cred());
 	if (!error)
 		*opened |= FILE_OPENED;
 }
 EXPORT_SYMBOL(finish_no_open);
+char *file_path(struct file *filp, char *buf, int buflen)
+{
+	return d_path(&filp->f_path, buf, buflen);
+}
+EXPORT_SYMBOL(file_path);
+/**
+ * vfs_open - open the file at the given path
+ * @path: path to open
+ * @file: newly allocated file with f_flag initialized
+ * @cred: credentials to use
+ */
+int vfs_open(const struct path *path, struct file *file,
+	     const struct cred *cred)
+{
+	struct dentry *dentry = path->dentry;
+	struct inode *inode = dentry->d_inode;
+	file->f_path = *path;
+	if (dentry->d_flags & DCACHE_OP_SELECT_INODE) {
+		inode = dentry->d_op->d_select_inode(dentry, file->f_flags);
+		if (IS_ERR(inode))
+			return PTR_ERR(inode);
+	}
+	return do_dentry_open(file, inode, NULL, cred);
+}
 struct file *dentry_open(const struct path *path, int flags,
 			 const struct cred *cred)
 {
 }
 EXPORT_SYMBOL(dentry_open);
-/**
- * vfs_open - open the file at the given path
- * @path: path to open
- * @filp: newly allocated file with f_flag initialized
- * @cred: credentials to use
- */
-int vfs_open(const struct path *path, struct file *filp,
-	     const struct cred *cred)
-{
-	struct inode *inode = path->dentry->d_inode;
-	if (inode->i_op->dentry_open)
-		return inode->i_op->dentry_open(path->dentry, filp, cred);
-	else {
-		filp->f_path = *path;
-		return do_dentry_open(filp, NULL, cred);
-	}
-}
-EXPORT_SYMBOL(vfs_open);
 static inline int build_open_flags(int flags, umode_t mode, struct open_flags *op)
 {
 	int lookup_flags = 0;

fs/overlayfs/inode.c+7−15

 	return true;
 }
-static int ovl_dentry_open(struct dentry *dentry, struct file *file,
+struct inode *ovl_d_select_inode(struct dentry *dentry, unsigned file_flags)
-		    const struct cred *cred)
 {
 	int err;
 	struct path realpath;
 	enum ovl_path_type type;
-	bool want_write = false;
 	type = ovl_path_real(dentry, &realpath);
-	if (ovl_open_need_copy_up(file->f_flags, type, realpath.dentry)) {
+	if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) {
-		want_write = true;
 		err = ovl_want_write(dentry);
 		if (err)
-			goto out;
+			return ERR_PTR(err);
-		if (file->f_flags & O_TRUNC)
+		if (file_flags & O_TRUNC)
 			err = ovl_copy_up_last(dentry, NULL, true);
 		else
 			err = ovl_copy_up(dentry);
+		ovl_drop_write(dentry);
 		if (err)
-			goto out_drop_write;
+			return ERR_PTR(err);
 		ovl_path_upper(dentry, &realpath);
 	}
-	err = vfs_open(&realpath, file, cred);
+	return d_backing_inode(realpath.dentry);
-out_drop_write:
-	if (want_write)
-		ovl_drop_write(dentry);
-out:
-	return err;
 }
 static const struct inode_operations ovl_file_inode_operations = {
 	.getxattr	= ovl_getxattr,
 	.listxattr	= ovl_listxattr,
 	.removexattr	= ovl_removexattr,
-	.dentry_open	= ovl_dentry_open,
 };
 static const struct inode_operations ovl_symlink_inode_operations = {

fs/overlayfs/overlayfs.h+1−0

@@ -173,6 +173,7 @@ ssize_t ovl_getxattr(struct dentry dentry, const char name, · 172 unmodified lines
173	void *value, size_t size);	173	void *value, size_t size);
174	ssize_t ovl_listxattr(struct dentry dentry, char list, size_t size);	174	ssize_t ovl_listxattr(struct dentry dentry, char list, size_t size);
175	int ovl_removexattr(struct dentry dentry, const char name);	175	int ovl_removexattr(struct dentry dentry, const char name);
		176	struct inode ovl_d_select_inode(struct dentry dentry, unsigned file_flags);
176		177
177	struct inode ovl_new_inode(struct super_block sb, umode_t mode,	178	struct inode ovl_new_inode(struct super_block sb, umode_t mode,
178	struct ovl_entry *oe);	179	struct ovl_entry *oe);

fs/overlayfs/super.c+1−0

@@ -316,6 +316,7 @@ static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags) · 315 unmodified lines
316		316
317	static const struct dentry_operations ovl_dentry_operations = {	317	static const struct dentry_operations ovl_dentry_operations = {
318	.d_release = ovl_dentry_release,	318	.d_release = ovl_dentry_release,
		319	.d_select_inode = ovl_d_select_inode,
319	};	320	};
320		321
321	static const struct dentry_operations ovl_reval_dentry_operations = {	322	static const struct dentry_operations ovl_reval_dentry_operations = {

fs/posix_acl.c+20−26

 		struct posix_acl **default_acl, struct posix_acl **acl)
 {
 	struct posix_acl *p;
+	struct posix_acl *clone;
 	int ret;
+	*acl = NULL;
+	*default_acl = NULL;
 	if (S_ISLNK(*mode) || !IS_POSIXACL(dir))
-		goto no_acl;
+		return 0;
 	p = get_acl(dir, ACL_TYPE_DEFAULT);
-	if (IS_ERR(p)) {
+	if (!p || p == ERR_PTR(-EOPNOTSUPP)) {
-		if (p == ERR_PTR(-EOPNOTSUPP))
+		*mode &= ~current_umask();
-			goto apply_umask;
+		return 0;
-		return PTR_ERR(p);
 	}
+	if (IS_ERR(p))
+		return PTR_ERR(p);
-	if (!p)
+	clone = posix_acl_clone(p, GFP_NOFS);
-		goto apply_umask;
+	if (!clone)
-	*acl = posix_acl_clone(p, GFP_NOFS);
-	if (!*acl)
 		goto no_mem;
-	ret = posix_acl_create_masq(*acl, mode);
+	ret = posix_acl_create_masq(clone, mode);
 	if (ret < 0)
 		goto no_mem_clone;
-	if (ret == 0) {
+	if (ret == 0)
-		posix_acl_release(*acl);
+		posix_acl_release(clone);
-		*acl = NULL;
+	else
-	}
+		*acl = clone;
-	if (!S_ISDIR(*mode)) {
+	if (!S_ISDIR(*mode))
 		posix_acl_release(p);
-		*default_acl = NULL;
+	else
-	} else {
 		*default_acl = p;
-	}
-	return 0;
-apply_umask:
-	*mode &= ~current_umask();
-no_acl:
-	*default_acl = NULL;
-	*acl = NULL;
 	return 0;
 no_mem_clone:
-	posix_acl_release(*acl);
+	posix_acl_release(clone);
 no_mem:
 	posix_acl_release(p);
 	return -ENOMEM;

fs/proc/nommu.c+1−1

@@ -64,7 +64,7 @@ static int nommu_region_show(struct seq_file m, struct vm_region region) · 63 unmodified lines
64		64
65	if (file) {	65	if (file) {
66	seq_pad(m, ' ');	66	seq_pad(m, ' ');
67	seq_path(m, &file->f_path, "");	67	seq_file_path(m, file, "");
68	}	68	}
69		69
70	seq_putc(m, '\n');	70	seq_putc(m, '\n');

fs/proc/task_mmu.c+2−2

@@ -310,7 +310,7 @@ show_map_vma(struct seq_file m, struct vm_area_struct vma, int is_pid) · 309 unmodified lines
310	*/	310	*/
311	if (file) {	311	if (file) {
312	seq_pad(m, ' ');	312	seq_pad(m, ' ');
313	seq_path(m, &file->f_path, "\n");	313	seq_file_path(m, file, "\n");
314	goto done;	314	goto done;
315	}	315	}
316		316
@@ -1509,7 +1509,7 @@ static int show_numa_map(struct seq_file m, void v, int is_pid) · 1192 unmodified lines
1509		1509
1510	if (file) {	1510	if (file) {
1511	seq_puts(m, " file=");	1511	seq_puts(m, " file=");
1512	seq_path(m, &file->f_path, "\n\t= ");	1512	seq_file_path(m, file, "\n\t= ");
1513	} else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {	1513	} else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {
1514	seq_puts(m, " heap");	1514	seq_puts(m, " heap");
1515	} else {	1515	} else {

fs/proc/task_nommu.c+1−1

@@ -180,7 +180,7 @@ static int nommu_vma_show(struct seq_file m, struct vm_area_struct vma, · 179 unmodified lines
180		180
181	if (file) {	181	if (file) {
182	seq_pad(m, ' ');	182	seq_pad(m, ' ');
183	seq_path(m, &file->f_path, "");	183	seq_file_path(m, file, "");
184	} else if (mm) {	184	} else if (mm) {
185	pid_t tid = pid_of_stack(priv, vma, is_pid);	185	pid_t tid = pid_of_stack(priv, vma, is_pid);
186		186

fs/qnx6/dir.c+0−5

 	return page;
 }
-static inline unsigned long dir_pages(struct inode *inode)
-{
-	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
-}
 static unsigned last_entry(struct inode *inode, unsigned long page_nr)
 {
 	unsigned long last_byte = inode->i_size;

fs/seq_file.c+14−0

@@ -490,6 +490,20 @@ int seq_path(struct seq_file m, const struct path path, const char *esc) · 489 unmodified lines
490	}	490	}
491	EXPORT_SYMBOL(seq_path);	491	EXPORT_SYMBOL(seq_path);
492		492
		493	/**
		494	* seq_file_path - seq_file interface to print a pathname of a file
		495	* @m: the seq_file handle
		496	* @file: the struct file to print
		497	* @esc: set of characters to escape in the output
		498	*
		499	* return the absolute path to the file.
		500	*/
		501	int seq_file_path(struct seq_file m, struct file file, const char *esc)
		502	{
		503	return seq_path(m, &file->f_path, esc);
		504	}
		505	EXPORT_SYMBOL(seq_file_path);
		506
493	/*	507	/*
494	* Same as seq_path, but relative to supplied root.	508	* Same as seq_path, but relative to supplied root.
495	*/	509	*/

fs/squashfs/squashfs_fs_i.h+1−1

@@ -49,6 +49,6 @@ struct squashfs_inode_info { · 48 unmodified lines
49		49
50	static inline struct squashfs_inode_info squashfs_i(struct inode inode)	50	static inline struct squashfs_inode_info squashfs_i(struct inode inode)
51	{	51	{
52	return list_entry(inode, struct squashfs_inode_info, vfs_inode);	52	return container_of(inode, struct squashfs_inode_info, vfs_inode);
53	}	53	}
54	#endif	54	#endif

fs/super.c+1−1

@@ -842,7 +842,7 @@ int get_anon_bdev(dev_t *p) · 841 unmodified lines
842	else if (error)	842	else if (error)
843	return -EAGAIN;	843	return -EAGAIN;
844		844
845	if (dev == (1 << MINORBITS)) {	845	if (dev >= (1 << MINORBITS)) {
846	spin_lock(&unnamed_dev_lock);	846	spin_lock(&unnamed_dev_lock);
847	ida_remove(&unnamed_dev_ida, dev);	847	ida_remove(&unnamed_dev_ida, dev);
848	if (unnamed_dev_start > dev)	848	if (unnamed_dev_start > dev)

fs/sysv/dir.c+0−5

 	page_cache_release(page);
 }
-static inline unsigned long dir_pages(struct inode *inode)
-{
-	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
-}
 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
 {
 	struct address_space *mapping = page->mapping;

fs/sysv/sysv.h+1−1

@@ -73,7 +73,7 @@ struct sysv_inode_info { · 72 unmodified lines
73		73
74	static inline struct sysv_inode_info SYSV_I(struct inode inode)	74	static inline struct sysv_inode_info SYSV_I(struct inode inode)
75	{	75	{
76	return list_entry(inode, struct sysv_inode_info, vfs_inode);	76	return container_of(inode, struct sysv_inode_info, vfs_inode);
77	}	77	}
78		78
79	static inline struct sysv_sb_info SYSV_SB(struct super_block sb)	79	static inline struct sysv_sb_info SYSV_SB(struct super_block sb)

fs/tracefs/inode.c+3−8

 	return dentry;
 }
-static inline int tracefs_positive(struct dentry *dentry)
-{
-	return dentry->d_inode && !d_unhashed(dentry);
-}
 static int __tracefs_remove(struct dentry *dentry, struct dentry *parent)
 {
 	int ret = 0;
-	if (tracefs_positive(dentry)) {
+	if (simple_positive(dentry)) {
 		if (dentry->d_inode) {
 			dget(dentry);
 			switch (dentry->d_inode->i_mode & S_IFMT) {
 	 */
 	spin_lock(&parent->d_lock);
 	list_for_each_entry(child, &parent->d_subdirs, d_child) {
-		if (!tracefs_positive(child))
+		if (!simple_positive(child))
 			continue;
 		/* perhaps simple_empty(child) makes more sense */
 		 * from d_subdirs. When releasing the parent->d_lock we can
 		 * no longer trust that the next pointer is valid.
 		 * Restart the loop. We'll skip this one with the
-		 * tracefs_positive() check.
+		 * simple_positive() check.
 		 */
 		goto loop;
 	}

fs/udf/udf_i.h+1−1

@@ -56,7 +56,7 @@ struct udf_inode_info { · 55 unmodified lines
56		56
57	static inline struct udf_inode_info UDF_I(struct inode inode)	57	static inline struct udf_inode_info UDF_I(struct inode inode)
58	{	58	{
59	return list_entry(inode, struct udf_inode_info, vfs_inode);	59	return container_of(inode, struct udf_inode_info, vfs_inode);
60	}	60	}
61		61
62	#endif /* _UDF_I_H) */	62	#endif /* _UDF_I_H) */

fs/ufs/balloc.c+17−17

@@ -51,8 +51,8 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count) · 50 unmodified lines
51		51
52	if (ufs_fragnum(fragment) + count > uspi->s_fpg)	52	if (ufs_fragnum(fragment) + count > uspi->s_fpg)
53	ufs_error (sb, "ufs_free_fragments", "internal error");	53	ufs_error (sb, "ufs_free_fragments", "internal error");
54		54
55	lock_ufs(sb);	55	mutex_lock(&UFS_SB(sb)->s_lock);
56		56
57	cgno = ufs_dtog(uspi, fragment);	57	cgno = ufs_dtog(uspi, fragment);
58	bit = ufs_dtogd(uspi, fragment);	58	bit = ufs_dtogd(uspi, fragment);
@@ -115,13 +115,13 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count) · 56 unmodified lines
115	if (sb->s_flags & MS_SYNCHRONOUS)	115	if (sb->s_flags & MS_SYNCHRONOUS)
116	ubh_sync_block(UCPI_UBH(ucpi));	116	ubh_sync_block(UCPI_UBH(ucpi));
117	ufs_mark_sb_dirty(sb);	117	ufs_mark_sb_dirty(sb);
118		118
119	unlock_ufs(sb);	119	mutex_unlock(&UFS_SB(sb)->s_lock);
120	UFSD("EXIT\n");	120	UFSD("EXIT\n");
121	return;	121	return;
122		122
123	failed:	123	failed:
124	unlock_ufs(sb);	124	mutex_unlock(&UFS_SB(sb)->s_lock);
125	UFSD("EXIT (FAILED)\n");	125	UFSD("EXIT (FAILED)\n");
126	return;	126	return;
127	}	127	}
@@ -151,7 +151,7 @@ void ufs_free_blocks(struct inode *inode, u64 fragment, unsigned count) · 23 unmodified lines
151	goto failed;	151	goto failed;
152	}	152	}
153		153
154	lock_ufs(sb);	154	mutex_lock(&UFS_SB(sb)->s_lock);
155		155
156	do_more:	156	do_more:
157	overflow = 0;	157	overflow = 0;
@@ -211,12 +211,12 @@ do_more: · 53 unmodified lines
211	}	211	}
212		212
213	ufs_mark_sb_dirty(sb);	213	ufs_mark_sb_dirty(sb);
214	unlock_ufs(sb);	214	mutex_unlock(&UFS_SB(sb)->s_lock);
215	UFSD("EXIT\n");	215	UFSD("EXIT\n");
216	return;	216	return;
217		217
218	failed_unlock:	218	failed_unlock:
219	unlock_ufs(sb);	219	mutex_unlock(&UFS_SB(sb)->s_lock);
220	failed:	220	failed:
221	UFSD("EXIT (FAILED)\n");	221	UFSD("EXIT (FAILED)\n");
222	return;	222	return;
@@ -357,7 +357,7 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 134 unmodified lines
357	usb1 = ubh_get_usb_first(uspi);	357	usb1 = ubh_get_usb_first(uspi);
358	*err = -ENOSPC;	358	*err = -ENOSPC;
359		359
360	lock_ufs(sb);	360	mutex_lock(&UFS_SB(sb)->s_lock);
361	tmp = ufs_data_ptr_to_cpu(sb, p);	361	tmp = ufs_data_ptr_to_cpu(sb, p);
362		362
363	if (count + ufs_fragnum(fragment) > uspi->s_fpb) {	363	if (count + ufs_fragnum(fragment) > uspi->s_fpb) {
@@ -378,19 +378,19 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 14 unmodified lines
378	"fragment %llu, tmp %llu\n",	378	"fragment %llu, tmp %llu\n",
379	(unsigned long long)fragment,	379	(unsigned long long)fragment,
380	(unsigned long long)tmp);	380	(unsigned long long)tmp);
381	unlock_ufs(sb);	381	mutex_unlock(&UFS_SB(sb)->s_lock);
382	return INVBLOCK;	382	return INVBLOCK;
383	}	383	}
384	if (fragment < UFS_I(inode)->i_lastfrag) {	384	if (fragment < UFS_I(inode)->i_lastfrag) {
385	UFSD("EXIT (ALREADY ALLOCATED)\n");	385	UFSD("EXIT (ALREADY ALLOCATED)\n");
386	unlock_ufs(sb);	386	mutex_unlock(&UFS_SB(sb)->s_lock);
387	return 0;	387	return 0;
388	}	388	}
389	}	389	}
390	else {	390	else {
391	if (tmp) {	391	if (tmp) {
392	UFSD("EXIT (ALREADY ALLOCATED)\n");	392	UFSD("EXIT (ALREADY ALLOCATED)\n");
393	unlock_ufs(sb);	393	mutex_unlock(&UFS_SB(sb)->s_lock);
394	return 0;	394	return 0;
395	}	395	}
396	}	396	}
@@ -399,7 +399,7 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 2 unmodified lines
399	* There is not enough space for user on the device	399	* There is not enough space for user on the device
400	*/	400	*/
401	if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {	401	if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {
402	unlock_ufs(sb);	402	mutex_unlock(&UFS_SB(sb)->s_lock);
403	UFSD("EXIT (FAILED)\n");	403	UFSD("EXIT (FAILED)\n");
404	return 0;	404	return 0;
405	}	405	}
@@ -424,7 +424,7 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 18 unmodified lines
424	ufs_clear_frags(inode, result + oldcount,	424	ufs_clear_frags(inode, result + oldcount,
425	newcount - oldcount, locked_page != NULL);	425	newcount - oldcount, locked_page != NULL);
426	}	426	}
427	unlock_ufs(sb);	427	mutex_unlock(&UFS_SB(sb)->s_lock);
428	UFSD("EXIT, result %llu\n", (unsigned long long)result);	428	UFSD("EXIT, result %llu\n", (unsigned long long)result);
429	return result;	429	return result;
430	}	430	}
@@ -439,7 +439,7 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 8 unmodified lines
439	fragment + count);	439	fragment + count);
440	ufs_clear_frags(inode, result + oldcount, newcount - oldcount,	440	ufs_clear_frags(inode, result + oldcount, newcount - oldcount,
441	locked_page != NULL);	441	locked_page != NULL);
442	unlock_ufs(sb);	442	mutex_unlock(&UFS_SB(sb)->s_lock);
443	UFSD("EXIT, result %llu\n", (unsigned long long)result);	443	UFSD("EXIT, result %llu\n", (unsigned long long)result);
444	return result;	444	return result;
445	}	445	}
@@ -477,7 +477,7 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 31 unmodified lines
477	*err = 0;	477	*err = 0;
478	UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,	478	UFS_I(inode)->i_lastfrag = max(UFS_I(inode)->i_lastfrag,
479	fragment + count);	479	fragment + count);
480	unlock_ufs(sb);	480	mutex_unlock(&UFS_SB(sb)->s_lock);
481	if (newcount < request)	481	if (newcount < request)
482	ufs_free_fragments (inode, result + newcount, request - newcount);	482	ufs_free_fragments (inode, result + newcount, request - newcount);
483	ufs_free_fragments (inode, tmp, oldcount);	483	ufs_free_fragments (inode, tmp, oldcount);
@@ -485,7 +485,7 @@ u64 ufs_new_fragments(struct inode inode, void p, u64 fragment, · 1 unmodified line
485	return result;	485	return result;
486	}	486	}
487		487
488	unlock_ufs(sb);	488	mutex_unlock(&UFS_SB(sb)->s_lock);
489	UFSD("EXIT (FAILED)\n");	489	UFSD("EXIT (FAILED)\n");
490	return 0;	490	return 0;
491	}	491	}

fs/ufs/dir.c+8−11

 	page_cache_release(page);
 }
-static inline unsigned long ufs_dir_pages(struct inode *inode)
-{
-	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
-}
 ino_t ufs_inode_by_name(struct inode *dir, const struct qstr *qstr)
 {
 	ino_t res = 0;
 /* Releases the page */
 void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
-		  struct page *page, struct inode *inode)
+		  struct page *page, struct inode *inode,
+		  bool update_times)
 {
 	loff_t pos = page_offset(page) +
 			(char *) de - (char *) page_address(page);
 	err = ufs_commit_chunk(page, pos, len);
 	ufs_put_page(page);
-	dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+	if (update_times)
+		dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 	mark_inode_dirty(dir);
 }
 	int namelen = qstr->len;
 	unsigned reclen = UFS_DIR_REC_LEN(namelen);
 	unsigned long start, n;
-	unsigned long npages = ufs_dir_pages(dir);
+	unsigned long npages = dir_pages(dir);
 	struct page *page = NULL;
 	struct ufs_inode_info *ui = UFS_I(dir);
 	struct ufs_dir_entry *de;
 	unsigned short rec_len, name_len;
 	struct page *page = NULL;
 	struct ufs_dir_entry *de;
-	unsigned long npages = ufs_dir_pages(dir);
+	unsigned long npages = dir_pages(dir);
 	unsigned long n;
 	char *kaddr;
 	loff_t pos;
 	struct super_block *sb = inode->i_sb;
 	unsigned int offset = pos & ~PAGE_CACHE_MASK;
 	unsigned long n = pos >> PAGE_CACHE_SHIFT;
-	unsigned long npages = ufs_dir_pages(inode);
+	unsigned long npages = dir_pages(inode);
 	unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
 	int need_revalidate = file->f_version != inode->i_version;
 	unsigned flags = UFS_SB(sb)->s_flags;
 {
 	struct super_block *sb = inode->i_sb;
 	struct page *page = NULL;
-	unsigned long i, npages = ufs_dir_pages(inode);
+	unsigned long i, npages = dir_pages(inode);
 	for (i = 0; i < npages; i++) {
 		char *kaddr;

fs/ufs/ialloc.c+8−8

@@ -69,11 +69,11 @@ void ufs_free_inode (struct inode * inode) · 68 unmodified lines
69		69
70	ino = inode->i_ino;	70	ino = inode->i_ino;
71		71
72	lock_ufs(sb);	72	mutex_lock(&UFS_SB(sb)->s_lock);
73		73
74	if (!((ino > 1) && (ino < (uspi->s_ncg * uspi->s_ipg )))) {	74	if (!((ino > 1) && (ino < (uspi->s_ncg * uspi->s_ipg )))) {
75	ufs_warning(sb, "ufs_free_inode", "reserved inode or nonexistent inode %u\n", ino);	75	ufs_warning(sb, "ufs_free_inode", "reserved inode or nonexistent inode %u\n", ino);
76	unlock_ufs(sb);	76	mutex_unlock(&UFS_SB(sb)->s_lock);
77	return;	77	return;
78	}	78	}
79		79
@@ -81,7 +81,7 @@ void ufs_free_inode (struct inode * inode) · 1 unmodified line
81	bit = ufs_inotocgoff (ino);	81	bit = ufs_inotocgoff (ino);
82	ucpi = ufs_load_cylinder (sb, cg);	82	ucpi = ufs_load_cylinder (sb, cg);
83	if (!ucpi) {	83	if (!ucpi) {
84	unlock_ufs(sb);	84	mutex_unlock(&UFS_SB(sb)->s_lock);
85	return;	85	return;
86	}	86	}
87	ucg = ubh_get_ucg(UCPI_UBH(ucpi));	87	ucg = ubh_get_ucg(UCPI_UBH(ucpi));
@@ -115,7 +115,7 @@ void ufs_free_inode (struct inode * inode) · 27 unmodified lines
115	ubh_sync_block(UCPI_UBH(ucpi));	115	ubh_sync_block(UCPI_UBH(ucpi));
116		116
117	ufs_mark_sb_dirty(sb);	117	ufs_mark_sb_dirty(sb);
118	unlock_ufs(sb);	118	mutex_unlock(&UFS_SB(sb)->s_lock);
119	UFSD("EXIT\n");	119	UFSD("EXIT\n");
120	}	120	}
121		121
@@ -193,7 +193,7 @@ struct inode ufs_new_inode(struct inode dir, umode_t mode) · 71 unmodified lines
193	sbi = UFS_SB(sb);	193	sbi = UFS_SB(sb);
194	uspi = sbi->s_uspi;	194	uspi = sbi->s_uspi;
195		195
196	lock_ufs(sb);	196	mutex_lock(&sbi->s_lock);
197		197
198	/*	198	/*
199	* Try to place the inode in its parent directory	199	* Try to place the inode in its parent directory
@@ -331,21 +331,21 @@ cg_found: · 131 unmodified lines
331	sync_dirty_buffer(bh);	331	sync_dirty_buffer(bh);
332	brelse(bh);	332	brelse(bh);
333	}	333	}
334	unlock_ufs(sb);	334	mutex_unlock(&sbi->s_lock);
335		335
336	UFSD("allocating inode %lu\n", inode->i_ino);	336	UFSD("allocating inode %lu\n", inode->i_ino);
337	UFSD("EXIT\n");	337	UFSD("EXIT\n");
338	return inode;	338	return inode;
339		339
340	fail_remove_inode:	340	fail_remove_inode:
341	unlock_ufs(sb);	341	mutex_unlock(&sbi->s_lock);
342	clear_nlink(inode);	342	clear_nlink(inode);
343	unlock_new_inode(inode);	343	unlock_new_inode(inode);
344	iput(inode);	344	iput(inode);
345	UFSD("EXIT (FAILED): err %d\n", err);	345	UFSD("EXIT (FAILED): err %d\n", err);
346	return ERR_PTR(err);	346	return ERR_PTR(err);
347	failed:	347	failed:
348	unlock_ufs(sb);	348	mutex_unlock(&sbi->s_lock);
349	make_bad_inode(inode);	349	make_bad_inode(inode);
350	iput (inode);	350	iput (inode);
351	UFSD("EXIT (FAILED): err %d\n", err);	351	UFSD("EXIT (FAILED): err %d\n", err);

fs/ufs/inode.c+4−1

 	invalidate_inode_buffers(inode);
 	clear_inode(inode);
-	if (want_delete)
+	if (want_delete) {
+		lock_ufs(inode->i_sb);
 		ufs_free_inode(inode);
+		unlock_ufs(inode->i_sb);
+	}
 }

fs/ufs/namei.c+33−46

 	if (dentry->d_name.len > UFS_MAXNAMLEN)
 		return ERR_PTR(-ENAMETOOLONG);
-	lock_ufs(dir->i_sb);
 	ino = ufs_inode_by_name(dir, &dentry->d_name);
 	if (ino)
 		inode = ufs_iget(dir->i_sb, ino);
-	unlock_ufs(dir->i_sb);
 	return d_splice_alias(inode, dentry);
 }
 		bool excl)
 {
 	struct inode *inode;
-	int err;
-	UFSD("BEGIN\n");
 	inode = ufs_new_inode(dir, mode);
-	err = PTR_ERR(inode);
+	if (IS_ERR(inode))
+		return PTR_ERR(inode);
-	if (!IS_ERR(inode)) {
+	inode->i_op = &ufs_file_inode_operations;
-		inode->i_op = &ufs_file_inode_operations;
+	inode->i_fop = &ufs_file_operations;
-		inode->i_fop = &ufs_file_operations;
+	inode->i_mapping->a_ops = &ufs_aops;
-		inode->i_mapping->a_ops = &ufs_aops;
+	mark_inode_dirty(inode);
-		mark_inode_dirty(inode);
+	return ufs_add_nondir(dentry, inode);
-		lock_ufs(dir->i_sb);
-		err = ufs_add_nondir(dentry, inode);
-		unlock_ufs(dir->i_sb);
-	}
-	UFSD("END: err=%d\n", err);
-	return err;
 }
 static int ufs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
 		init_special_inode(inode, mode, rdev);
 		ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev);
 		mark_inode_dirty(inode);
-		lock_ufs(dir->i_sb);
 		err = ufs_add_nondir(dentry, inode);
-		unlock_ufs(dir->i_sb);
 	}
 	return err;
 }
 	const char * symname)
 {
 	struct super_block * sb = dir->i_sb;
-	int err = -ENAMETOOLONG;
+	int err;
 	unsigned l = strlen(symname)+1;
 	struct inode * inode;
 	if (l > sb->s_blocksize)
-		goto out_notlocked;
+		return -ENAMETOOLONG;
 	inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO);
 	err = PTR_ERR(inode);
 	if (IS_ERR(inode))
-		goto out_notlocked;
+		return err;
-	lock_ufs(dir->i_sb);
 	if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) {
 		/* slow symlink */
 		inode->i_op = &ufs_symlink_inode_operations;
 	}
 	mark_inode_dirty(inode);
-	err = ufs_add_nondir(dentry, inode);
+	return ufs_add_nondir(dentry, inode);
-out:
-	unlock_ufs(dir->i_sb);
-out_notlocked:
-	return err;
 out_fail:
 	inode_dec_link_count(inode);
 	unlock_new_inode(inode);
 	iput(inode);
-	goto out;
+	return err;
 }
 static int ufs_link (struct dentry * old_dentry, struct inode * dir,
 	struct inode *inode = d_inode(old_dentry);
 	int error;
-	lock_ufs(dir->i_sb);
 	inode->i_ctime = CURRENT_TIME_SEC;
 	inode_inc_link_count(inode);
 	ihold(inode);
-	error = ufs_add_nondir(dentry, inode);
+	error = ufs_add_link(dentry, inode);
-	unlock_ufs(dir->i_sb);
+	if (error) {
+		inode_dec_link_count(inode);
+		iput(inode);
+	} else
+		d_instantiate(dentry, inode);
 	return error;
 }
 	struct inode * inode;
 	int err;
+	inode_inc_link_count(dir);
 	inode = ufs_new_inode(dir, S_IFDIR|mode);
+	err = PTR_ERR(inode);
 	if (IS_ERR(inode))
-		return PTR_ERR(inode);
+		goto out_dir;
 	inode->i_op = &ufs_dir_inode_operations;
 	inode->i_fop = &ufs_dir_operations;
 	inode_inc_link_count(inode);
-	lock_ufs(dir->i_sb);
-	inode_inc_link_count(dir);
 	err = ufs_make_empty(inode, dir);
 	if (err)
 		goto out_fail;
 	err = ufs_add_link(dentry, inode);
 	if (err)
 		goto out_fail;
-	unlock_ufs(dir->i_sb);
+	unlock_new_inode(inode);
 	d_instantiate(dentry, inode);
-out:
+	return 0;
-	return err;
 out_fail:
 	inode_dec_link_count(inode);
 	inode_dec_link_count(inode);
 	unlock_new_inode(inode);
 	iput (inode);
+out_dir:
 	inode_dec_link_count(dir);
-	unlock_ufs(dir->i_sb);
+	return err;
-	goto out;
 }
 static int ufs_unlink(struct inode *dir, struct dentry *dentry)
 	struct inode * inode = d_inode(dentry);
 	int err= -ENOTEMPTY;
-	lock_ufs(dir->i_sb);
 	if (ufs_empty_dir (inode)) {
 		err = ufs_unlink(dir, dentry);
 		if (!err) {
 			inode_dec_link_count(dir);
 		}
 	}
-	unlock_ufs(dir->i_sb);
 	return err;
 }
 		new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page);
 		if (!new_de)
 			goto out_dir;
-		ufs_set_link(new_dir, new_de, new_page, old_inode);
+		ufs_set_link(new_dir, new_de, new_page, old_inode, 1);
 		new_inode->i_ctime = CURRENT_TIME_SEC;
 		if (dir_de)
 			drop_nlink(new_inode);
 	mark_inode_dirty(old_inode);
 	if (dir_de) {
-		ufs_set_link(old_inode, dir_de, dir_page, new_dir);
+		if (old_dir != new_dir)
+			ufs_set_link(old_inode, dir_de, dir_page, new_dir, 0);
+		else {
+			kunmap(dir_page);
+			page_cache_release(dir_page);
+		}
 		inode_dec_link_count(old_dir);
 	}
 	return 0;

fs/ufs/super.c+11−0

 	unsigned flags;
 	lock_ufs(sb);
+	mutex_lock(&UFS_SB(sb)->s_lock);
 	UFSD("ENTER\n");
 	ufs_put_cstotal(sb);
 	UFSD("EXIT\n");
+	mutex_unlock(&UFS_SB(sb)->s_lock);
 	unlock_ufs(sb);
 	return 0;
 	UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
 	mutex_init(&sbi->mutex);
+	mutex_init(&sbi->s_lock);
 	spin_lock_init(&sbi->work_lock);
 	INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
 	/*
 	sync_filesystem(sb);
 	lock_ufs(sb);
+	mutex_lock(&UFS_SB(sb)->s_lock);
 	uspi = UFS_SB(sb)->s_uspi;
 	flags = UFS_SB(sb)->s_flags;
 	usb1 = ubh_get_usb_first(uspi);
 	new_mount_opt = 0;
 	ufs_set_opt (new_mount_opt, ONERROR_LOCK);
 	if (!ufs_parse_options (data, &new_mount_opt)) {
+		mutex_unlock(&UFS_SB(sb)->s_lock);
 		unlock_ufs(sb);
 		return -EINVAL;
 	}
 		new_mount_opt |= ufstype;
 	} else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
 		pr_err("ufstype can't be changed during remount\n");
+		mutex_unlock(&UFS_SB(sb)->s_lock);
 		unlock_ufs(sb);
 		return -EINVAL;
 	}
 	if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
 		UFS_SB(sb)->s_mount_opt = new_mount_opt;
+		mutex_unlock(&UFS_SB(sb)->s_lock);
 		unlock_ufs(sb);
 		return 0;
 	}
 	 */
 #ifndef CONFIG_UFS_FS_WRITE
 		pr_err("ufs was compiled with read-only support, can't be mounted as read-write\n");
+		mutex_unlock(&UFS_SB(sb)->s_lock);
 		unlock_ufs(sb);
 		return -EINVAL;
 #else
 		    ufstype != UFS_MOUNT_UFSTYPE_SUNx86 &&
 		    ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
 			pr_err("this ufstype is read-only supported\n");
+			mutex_unlock(&UFS_SB(sb)->s_lock);
 			unlock_ufs(sb);
 			return -EINVAL;
 		}
 		if (!ufs_read_cylinder_structures(sb)) {
 			pr_err("failed during remounting\n");
+			mutex_unlock(&UFS_SB(sb)->s_lock);
 			unlock_ufs(sb);
 			return -EPERM;
 		}
 #endif
 	}
 	UFS_SB(sb)->s_mount_opt = new_mount_opt;
+	mutex_unlock(&UFS_SB(sb)->s_lock);
 	unlock_ufs(sb);
 	return 0;
 }

fs/ufs/ufs.h+2−1

 	int work_queued; /* non-zero if the delayed work is queued */
 	struct delayed_work sync_work; /* FS sync delayed work */
 	spinlock_t work_lock; /* protects sync_work and work_queued */
+	struct mutex s_lock;
 };
 struct ufs_inode_info {
 extern int ufs_empty_dir (struct inode *);
 extern struct ufs_dir_entry *ufs_dotdot(struct inode *, struct page **);
 extern void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
-			 struct page *page, struct inode *inode);
+			 struct page *page, struct inode *inode, bool update_times);
 /* file.c */
 extern const struct inode_operations ufs_file_inode_operations;

fs/xfs/xfs_file.c+10−1

 	if (error)
 		return error;
+	/* For changing security info in file_remove_privs() we need i_mutex */
+	if (*iolock == XFS_IOLOCK_SHARED && !IS_NOSEC(inode)) {
+		xfs_rw_iunlock(ip, *iolock);
+		*iolock = XFS_IOLOCK_EXCL;
+		xfs_rw_ilock(ip, *iolock);
+		goto restart;
+	}
 	/*
 	 * If the offset is beyond the size of the file, we need to zero any
 	 * blocks that fall between the existing EOF and the start of this
 	 * setgid bits if the process is not being run by root.  This keeps
 	 * people from modifying setuid and setgid binaries.
 	 */
-	return file_remove_suid(file);
+	if (!IS_NOSEC(inode))
+		return file_remove_privs(file);
+	return 0;
 }
 /*

include/linux/dcache.h+7−0

 	char *(*d_dname)(struct dentry *, char *, int);
 	struct vfsmount *(*d_automount)(struct path *);
 	int (*d_manage)(struct dentry *, bool);
+	struct inode *(*d_select_inode)(struct dentry *, unsigned);
 } ____cacheline_aligned;
 /*
 #define DCACHE_MAY_FREE			0x00800000
 #define DCACHE_FALLTHRU			0x01000000 /* Fall through to lower layer */
+#define DCACHE_OP_SELECT_INODE		0x02000000 /* Unioned entry: dcache op selects inode */
 extern seqlock_t rename_lock;
 	return dentry->d_inode != NULL;
 }
+static inline int simple_positive(struct dentry *dentry)
+{
+	return d_really_is_positive(dentry) && !d_unhashed(dentry);
+}
 extern void d_set_fallthru(struct dentry *dentry);
 static inline bool d_is_fallthru(const struct dentry *dentry)

include/linux/fdtable.h+3−0

    * read mostly part
    */
 	atomic_t count;
+	bool resize_in_progress;
+	wait_queue_head_t resize_wait;
 	struct fdtable __rcu *fdt;
 	struct fdtable fdtab;
   /*

include/linux/fs.h+8−3

 	int (*set_acl)(struct inode *, struct posix_acl *, int);
 	/* WARNING: probably going away soon, do not use! */
-	int (*dentry_open)(struct dentry *, struct file *, const struct cred *);
 } ____cacheline_aligned;
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 extern struct file *filp_open(const char *, int, umode_t);
 extern struct file *file_open_root(struct dentry *, struct vfsmount *,
 				   const char *, int);
-extern int vfs_open(const struct path *, struct file *, const struct cred *);
 extern struct file * dentry_open(const struct path *, int, const struct cred *);
 extern int filp_close(struct file *, fl_owner_t id);
 extern int is_subdir(struct dentry *, struct dentry *);
 extern int path_is_under(struct path *, struct path *);
+extern char *file_path(struct file *, char *, int);
 #include <linux/err.h>
 /* needed for stackable file system support */
 extern struct inode *new_inode(struct super_block *sb);
 extern void free_inode_nonrcu(struct inode *inode);
 extern int should_remove_suid(struct dentry *);
-extern int file_remove_suid(struct file *);
+extern int file_remove_privs(struct file *);
+extern int dentry_needs_remove_privs(struct dentry *dentry);
+static inline int file_needs_remove_privs(struct file *file)
+{
+	return dentry_needs_remove_privs(file->f_path.dentry);
+}
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 static inline void insert_inode_hash(struct inode *inode)

include/linux/fscache-cache.h+27−28

@@ -74,6 +74,7 @@ extern wait_queue_head_t fscache_cache_cleared_wq; · 73 unmodified lines
74	*/	74	*/
75	typedef void (fscache_operation_release_t)(struct fscache_operation op);	75	typedef void (fscache_operation_release_t)(struct fscache_operation op);
76	typedef void (fscache_operation_processor_t)(struct fscache_operation op);	76	typedef void (fscache_operation_processor_t)(struct fscache_operation op);
		77	typedef void (fscache_operation_cancel_t)(struct fscache_operation op);
77		78
78	enum fscache_operation_state {	79	enum fscache_operation_state {
79	FSCACHE_OP_ST_BLANK, /* Op is not yet submitted */	80	FSCACHE_OP_ST_BLANK, /* Op is not yet submitted */
@@ -109,6 +110,9 @@ struct fscache_operation { · 29 unmodified lines
109	* the op in a non-pool thread */	110	* the op in a non-pool thread */
110	fscache_operation_processor_t processor;	111	fscache_operation_processor_t processor;
111		112
		113	/* Operation cancellation cleanup (optional) */
		114	fscache_operation_cancel_t cancel;
		115
112	/* operation releaser */	116	/* operation releaser */
113	fscache_operation_release_t release;	117	fscache_operation_release_t release;
114	};	118	};
@@ -119,33 +123,17 @@ extern void fscache_op_work_func(struct work_struct *work); · 4 unmodified lines
119	extern void fscache_enqueue_operation(struct fscache_operation *);	123	extern void fscache_enqueue_operation(struct fscache_operation *);
120	extern void fscache_op_complete(struct fscache_operation *, bool);	124	extern void fscache_op_complete(struct fscache_operation *, bool);
121	extern void fscache_put_operation(struct fscache_operation *);	125	extern void fscache_put_operation(struct fscache_operation *);
122		126	extern void fscache_operation_init(struct fscache_operation *,
123	/**	127	fscache_operation_processor_t,
124	* fscache_operation_init - Do basic initialisation of an operation	128	fscache_operation_cancel_t,
125	* @op: The operation to initialise	129	fscache_operation_release_t);
126	* @release: The release function to assign
127	*
128	* Do basic initialisation of an operation. The caller must still set flags,
129	* object and processor if needed.
130	*/
131	static inline void fscache_operation_init(struct fscache_operation *op,
132	fscache_operation_processor_t processor,
133	fscache_operation_release_t release)
134	{
135	INIT_WORK(&op->work, fscache_op_work_func);
136	atomic_set(&op->usage, 1);
137	op->state = FSCACHE_OP_ST_INITIALISED;
138	op->debug_id = atomic_inc_return(&fscache_op_debug_id);
139	op->processor = processor;
140	op->release = release;
141	INIT_LIST_HEAD(&op->pend_link);
142	}
143		130
144	/*	131	/*
145	* data read operation	132	* data read operation
146	*/	133	*/
147	struct fscache_retrieval {	134	struct fscache_retrieval {
148	struct fscache_operation op;	135	struct fscache_operation op;
		136	struct fscache_cookie cookie; / The netfs cookie */
149	struct address_space mapping; / netfs pages */	137	struct address_space mapping; / netfs pages */
150	fscache_rw_complete_t end_io_func; /* function to call on I/O completion */	138	fscache_rw_complete_t end_io_func; /* function to call on I/O completion */
151	void context; / netfs read context (pinned) */	139	void context; / netfs read context (pinned) */
@@ -371,6 +359,7 @@ struct fscache_object { · 219 unmodified lines
371	#define FSCACHE_OBJECT_IS_LOOKED_UP 4 /* T if object has been looked up */	359	#define FSCACHE_OBJECT_IS_LOOKED_UP 4 /* T if object has been looked up */
372	#define FSCACHE_OBJECT_IS_AVAILABLE 5 /* T if object has become active */	360	#define FSCACHE_OBJECT_IS_AVAILABLE 5 /* T if object has become active */
373	#define FSCACHE_OBJECT_RETIRED 6 /* T if object was retired on relinquishment */	361	#define FSCACHE_OBJECT_RETIRED 6 /* T if object was retired on relinquishment */
		362	#define FSCACHE_OBJECT_KILLED_BY_CACHE 7 /* T if object was killed by the cache */
374		363
375	struct list_head cache_link; /* link in cache->object_list */	364	struct list_head cache_link; /* link in cache->object_list */
376	struct hlist_node cookie_link; /* link in cookie->backing_objects */	365	struct hlist_node cookie_link; /* link in cookie->backing_objects */
@@ -410,17 +399,16 @@ static inline bool fscache_object_is_available(struct fscache_object *object) · 33 unmodified lines
410	return test_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags);	399	return test_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags);
411	}	400	}
412		401
413	static inline bool fscache_object_is_active(struct fscache_object *object)	402	static inline bool fscache_cache_is_broken(struct fscache_object *object)
414	{	403	{
415	return fscache_object_is_available(object) &&	404	return test_bit(FSCACHE_IOERROR, &object->cache->flags);
416	fscache_object_is_live(object) &&
417	!test_bit(FSCACHE_IOERROR, &object->cache->flags);
418	}	405	}
419		406
420	static inline bool fscache_object_is_dead(struct fscache_object *object)	407	static inline bool fscache_object_is_active(struct fscache_object *object)
421	{	408	{
422	return fscache_object_is_dying(object) &&	409	return fscache_object_is_available(object) &&
423	test_bit(FSCACHE_IOERROR, &object->cache->flags);	410	fscache_object_is_live(object) &&
		411	!fscache_cache_is_broken(object);
424	}	412	}
425		413
426	/**	414	/**
@@ -551,4 +539,15 @@ extern enum fscache_checkaux fscache_check_aux(struct fscache_object *object, · 124 unmodified lines
551	const void *data,	539	const void *data,
552	uint16_t datalen);	540	uint16_t datalen);
553		541
		542	extern void fscache_object_retrying_stale(struct fscache_object *object);
		543
		544	enum fscache_why_object_killed {
		545	FSCACHE_OBJECT_IS_STALE,
		546	FSCACHE_OBJECT_NO_SPACE,
		547	FSCACHE_OBJECT_WAS_RETIRED,
		548	FSCACHE_OBJECT_WAS_CULLED,
		549	};
		550	extern void fscache_object_mark_killed(struct fscache_object *object,
		551	enum fscache_why_object_killed why);
		552
554	#endif /* _LINUX_FSCACHE_CACHE_H */	553	#endif /* _LINUX_FSCACHE_CACHE_H */

include/linux/pagemap.h+6−0

@@ -671,4 +671,10 @@ static inline int add_to_page_cache(struct page *page, · 670 unmodified lines
671	return error;	671	return error;
672	}	672	}
673		673
		674	static inline unsigned long dir_pages(struct inode *inode)
		675	{
		676	return (unsigned long)(inode->i_size + PAGE_CACHE_SIZE - 1) >>
		677	PAGE_CACHE_SHIFT;
		678	}
		679
674	#endif /* _LINUX_PAGEMAP_H */	680	#endif /* _LINUX_PAGEMAP_H */

include/linux/seq_file.h+1−0

@@ -123,6 +123,7 @@ __printf(2, 3) int seq_printf(struct seq_file , const char , ...); · 122 unmodified lines
123	__printf(2, 0) int seq_vprintf(struct seq_file , const char , va_list args);	123	__printf(2, 0) int seq_vprintf(struct seq_file , const char , va_list args);
124		124
125	int seq_path(struct seq_file , const struct path , const char *);	125	int seq_path(struct seq_file , const struct path , const char *);
		126	int seq_file_path(struct seq_file , struct file , const char *);
126	int seq_dentry(struct seq_file , struct dentry , const char *);	127	int seq_dentry(struct seq_file , struct dentry , const char *);
127	int seq_path_root(struct seq_file m, const struct path path,	128	int seq_path_root(struct seq_file m, const struct path path,
128	const struct path root, const char esc);	129	const struct path root, const char esc);

kernel/events/core.c+1−1

@@ -5794,7 +5794,7 @@ static void perf_event_mmap_event(struct perf_mmap_event *mmap_event) · 5793 unmodified lines
5794	* need to add enough zero bytes after the string to handle	5794	* need to add enough zero bytes after the string to handle
5795	* the 64bit alignment we do later.	5795	* the 64bit alignment we do later.
5796	*/	5796	*/
5797	name = d_path(&file->f_path, buf, PATH_MAX - sizeof(u64));	5797	name = file_path(file, buf, PATH_MAX - sizeof(u64));
5798	if (IS_ERR(name)) {	5798	if (IS_ERR(name)) {
5799	name = "//toolong";	5799	name = "//toolong";
5800	goto cpy_name;	5800	goto cpy_name;

mm/filemap.c+1−1

@@ -2563,7 +2563,7 @@ ssize_t __generic_file_write_iter(struct kiocb iocb, struct iov_iter from) · 2562 unmodified lines
2563		2563
2564	/* We can write back this queue in page reclaim */	2564	/* We can write back this queue in page reclaim */
2565	current->backing_dev_info = inode_to_bdi(inode);	2565	current->backing_dev_info = inode_to_bdi(inode);
2566	err = file_remove_suid(file);	2566	err = file_remove_privs(file);
2567	if (err)	2567	if (err)
2568	goto out;	2568	goto out;
2569		2569

mm/memory.c+1−1

@@ -3726,7 +3726,7 @@ void print_vma_addr(char *prefix, unsigned long ip) · 3725 unmodified lines
3726	if (buf) {	3726	if (buf) {
3727	char *p;	3727	char *p;
3728		3728
3729	p = d_path(&f->f_path, buf, PAGE_SIZE);	3729	p = file_path(f, buf, PAGE_SIZE);
3730	if (IS_ERR(p))	3730	if (IS_ERR(p))
3731	p = "?";	3731	p = "?";
3732	printk("%s%s[%lx+%lx]", prefix, kbasename(p),	3732	printk("%s%s[%lx+%lx]", prefix, kbasename(p),

mm/swapfile.c+1−1

@@ -2032,7 +2032,7 @@ static int swap_show(struct seq_file swap, void v) · 2031 unmodified lines
2032	}	2032	}
2033		2033
2034	file = si->swap_file;	2034	file = si->swap_file;
2035	len = seq_path(swap, &file->f_path, " \t\n\\");	2035	len = seq_file_path(swap, file, " \t\n\\");
2036	seq_printf(swap, "%*s%s\t%u\t%u\t%d\n",	2036	seq_printf(swap, "%*s%s\t%u\t%u\t%d\n",
2037	len < 40 ? 40 - len : 1, " ",	2037	len < 40 ? 40 - len : 1, " ",
2038	S_ISBLK(file_inode(file)->i_mode) ?	2038	S_ISBLK(file_inode(file)->i_mode) ?

net/9p/client.c+11−1

 	if (err < 0) {
 		if (err == -EIO)
 			c->status = Disconnected;
-		goto reterr;
+		if (err != -ERESTARTSYS)
+			goto reterr;
 	}
 	if (req->status == REQ_STATUS_ERROR) {
 		p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
 			p9_free_req(clnt, req);
 			break;
 		}
+		if (rsize < count) {
+			pr_err("bogus RREAD count (%d > %d)\n", count, rsize);
+			count = rsize;
+		}
 		p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
 		if (!count) {
 		if (*err) {
 			trace_9p_protocol_dump(clnt, req->rc);
 			p9_free_req(clnt, req);
+			break;
+		}
+		if (rsize < count) {
+			pr_err("bogus RWRITE count (%d > %d)\n", count, rsize);
+			count = rsize;
 		}
 		p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);

security/inode.c+6−13

 static struct vfsmount *mount;
 static int mount_count;
-static inline int positive(struct dentry *dentry)
-{
-	return d_really_is_positive(dentry) && !d_unhashed(dentry);
-}
 static int fill_super(struct super_block *sb, void *data, int silent)
 {
 	static struct tree_descr files[] = {{""}};
 		return;
 	mutex_lock(&d_inode(parent)->i_mutex);
-	if (positive(dentry)) {
+	if (simple_positive(dentry)) {
-		if (d_really_is_positive(dentry)) {
+		if (d_is_dir(dentry))
-			if (d_is_dir(dentry))
+			simple_rmdir(d_inode(parent), dentry);
-				simple_rmdir(d_inode(parent), dentry);
+		else
-			else
+			simple_unlink(d_inode(parent), dentry);
-				simple_unlink(d_inode(parent), dentry);
+		dput(dentry);
-			dput(dentry);
-		}
 	}
 	mutex_unlock(&d_inode(parent)->i_mutex);
 	simple_release_fs(&mount, &mount_count);

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code