Attachment #222867 for bug #253500

Lines 437-446 fuse_vnop_advlock(struct vop_advlock_args *ap) Link Here

(-)b/sys/fs/fuse/fuse_vnops.c (-3 / +7 lines)
437	op = FUSE_GETLK;	437	op = FUSE_GETLK;
438	break;	438	break;
439	case F_SETLK:	439	case F_SETLK:
440	op = FUSE_SETLK;	440	if (flags & F_WAIT)
		441	op = FUSE_SETLKW;
		442	else
		443	op = FUSE_SETLK;
441	break;	444	break;
442	case F_SETLKW:	445	case F_UNLCK:
443	op = FUSE_SETLKW;	446	op = FUSE_SETLK;
		447	flags \|= F_UNLCK;
444	break;	448	break;
445	default:	449	default:
446	return EINVAL;	450	return EINVAL;




		ResultOf([=](auto in) {
			return (in.header.opcode == FUSE_SETLK &&
				in.header.nodeid == ino &&
				in.body.setlk.lk.type == F_RDLCK &&
				in.body.setlk.fh == FH);
		}, Eq(true)),
		_)
	).WillOnce(Invoke(ReturnErrno(0)));
	EXPECT_CALL(*m_mock, process(
		ResultOf([=](auto in) {
			return (in.header.opcode == FUSE_SETLK &&
				in.header.nodeid == ino &&
				in.body.setlk.lk.type == F_UNLCK &&
				in.body.setlk.fh == FH);
		}, Eq(true)),
		_)

	fl.l_type = F_RDLCK;
	fl.l_whence = SEEK_SET;
	fl.l_sysid = 0;
	ASSERT_NE(-1, fcntl(fd, F_SETLK, &fl)) << strerror(errno);

	fd2 = open(FULLPATH, O_WRONLY);
	ASSERT_LE(0, fd2) << strerror(errno);




			return (in.header.opcode == FUSE_SETLK &&
				in.header.nodeid == ino &&
				in.body.setlk.fh == FH &&
				in.body.setlk.owner == (uint32_t)pid &&
				in.body.setlk.lk.start == start &&
				in.body.setlk.lk.end == end &&
				in.body.setlk.lk.type == type &&
				in.body.setlk.lk.pid == (uint64_t)pid);
		}, Eq(true)),
		_)
	).WillOnce(Invoke(ReturnErrno(err)));
}
void expect_setlkw(uint64_t ino, pid_t pid, uint64_t start, uint64_t end,
	uint32_t type, int err)
{
	EXPECT_CALL(*m_mock, process(
		ResultOf([=](auto in) {
			return (in.header.opcode == FUSE_SETLKW &&
				in.header.nodeid == ino &&
				in.body.setlkw.fh == FH &&
				in.body.setlkw.owner == (uint32_t)pid &&
				in.body.setlkw.lk.start == start &&
				in.body.setlkw.lk.end == end &&

	leak(fd);
}

/* Clear a lock with FUSE_SETLK */
TEST_F(Setlk, clear)
{
	const char FULLPATH[] = "mountpoint/some_file.txt";
	const char RELPATH[] = "some_file.txt";
	uint64_t ino = 42;
	struct flock fl;
	int fd;
	pid_t pid = 1234;

	expect_lookup(RELPATH, ino);
	expect_open(ino, 0, 1);
	expect_setlk(ino, pid, 10, 1009, F_UNLCK, 0);

	fd = open(FULLPATH, O_RDWR);
	ASSERT_LE(0, fd) << strerror(errno);
	fl.l_start = 10;
	fl.l_len = 1000;
	fl.l_pid = pid;
	fl.l_type = F_UNLCK;
	fl.l_whence = SEEK_SET;
	fl.l_sysid = 0;
	ASSERT_NE(-1, fcntl(fd, F_SETLK, &fl)) << strerror(errno);
	leak(fd);
}

/* Set a new lock with FUSE_SETLK */
TEST_F(Setlk, set)
{


	expect_lookup(RELPATH, ino);
	expect_open(ino, 0, 1);
	expect_setlkw(ino, pid, 10, 1009, F_RDLCK, 0);

	fd = open(FULLPATH, O_RDWR);
	ASSERT_LE(0, fd) << strerror(errno);




		ResultOf([=](auto in) {
			return (in.header.opcode == FUSE_SETLK &&
				in.header.nodeid == ino &&
				in.body.setlk.lk.type == F_RDLCK &&
				in.body.setlk.fh == FH);
		}, Eq(true)),
		_)
	).WillOnce(Invoke(ReturnErrno(0)));
	EXPECT_CALL(*m_mock, process(
		ResultOf([=](auto in) {
			return (in.header.opcode == FUSE_SETLK &&
				in.header.nodeid == ino &&
				in.body.setlk.lk.type == F_UNLCK &&
				in.body.setlk.fh == FH);
		}, Eq(true)),
		_)

	fl.l_type = F_RDLCK;
	fl.l_whence = SEEK_SET;
	fl.l_sysid = 0;
	ASSERT_NE(-1, fcntl(fd, F_SETLK, &fl)) << strerror(errno);

	ASSERT_EQ(0, close(fd)) << strerror(errno);
}
- 

Return to bug 253500

Lines 210-215 TEST_F(FlushWithLocks, unlock_on_close) Link Here

(-)b/tests/sys/fs/fusefs/flush.cc (-1 / +11 lines)
210	ResultOf([=](auto in) {	210	ResultOf([=](auto in) {
211	return (in.header.opcode == FUSE_SETLK &&	211	return (in.header.opcode == FUSE_SETLK &&
212	in.header.nodeid == ino &&	212	in.header.nodeid == ino &&
		213	in.body.setlk.lk.type == F_RDLCK &&
		214	in.body.setlk.fh == FH);
		215	}, Eq(true)),
		216	_)
		217	).WillOnce(Invoke(ReturnErrno(0)));
		218	EXPECT_CALL(*m_mock, process(
		219	ResultOf([=](auto in) {
		220	return (in.header.opcode == FUSE_SETLK &&
		221	in.header.nodeid == ino &&
		222	in.body.setlk.lk.type == F_UNLCK &&
213	in.body.setlk.fh == FH);	223	in.body.setlk.fh == FH);
214	}, Eq(true)),	224	}, Eq(true)),
215	_)	225	_)
Lines 224-230 TEST_F(FlushWithLocks, unlock_on_close) Link Here
224	fl.l_type = F_RDLCK;	234	fl.l_type = F_RDLCK;
225	fl.l_whence = SEEK_SET;	235	fl.l_whence = SEEK_SET;
226	fl.l_sysid = 0;	236	fl.l_sysid = 0;
227	ASSERT_NE(-1, fcntl(fd, F_SETLKW, &fl)) << strerror(errno);	237	ASSERT_NE(-1, fcntl(fd, F_SETLK, &fl)) << strerror(errno);
228		238
229	fd2 = open(FULLPATH, O_WRONLY);	239	fd2 = open(FULLPATH, O_WRONLY);
230	ASSERT_LE(0, fd2) << strerror(errno);	240	ASSERT_LE(0, fd2) << strerror(errno);

Lines 72-77 void expect_setlk(uint64_t ino, pid_t pid, uint64_t start, uint64_t end, Link Here

(-)b/tests/sys/fs/fusefs/locks.cc (-1 / +44 lines)
72	return (in.header.opcode == FUSE_SETLK &&	72	return (in.header.opcode == FUSE_SETLK &&
73	in.header.nodeid == ino &&	73	in.header.nodeid == ino &&
74	in.body.setlk.fh == FH &&	74	in.body.setlk.fh == FH &&
		75	in.body.setlk.owner == (uint32_t)pid &&
		76	in.body.setlk.lk.start == start &&
		77	in.body.setlk.lk.end == end &&
		78	in.body.setlk.lk.type == type &&
		79	in.body.setlk.lk.pid == (uint64_t)pid);
		80	}, Eq(true)),
		81	_)
		82	).WillOnce(Invoke(ReturnErrno(err)));
		83	}
		84	void expect_setlkw(uint64_t ino, pid_t pid, uint64_t start, uint64_t end,
		85	uint32_t type, int err)
		86	{
		87	EXPECT_CALL(*m_mock, process(
		88	ResultOf([=](auto in) {
		89	return (in.header.opcode == FUSE_SETLKW &&
		90	in.header.nodeid == ino &&
		91	in.body.setlkw.fh == FH &&
75	in.body.setlkw.owner == (uint32_t)pid &&	92	in.body.setlkw.owner == (uint32_t)pid &&
76	in.body.setlkw.lk.start == start &&	93	in.body.setlkw.lk.start == start &&
77	in.body.setlkw.lk.end == end &&	94	in.body.setlkw.lk.end == end &&
Lines 343-348 TEST_F(SetlkFallback, local) Link Here
343	leak(fd);	360	leak(fd);
344	}	361	}
345		362
		363	/* Clear a lock with FUSE_SETLK */
		364	TEST_F(Setlk, clear)
		365	{
		366	const char FULLPATH[] = "mountpoint/some_file.txt";
		367	const char RELPATH[] = "some_file.txt";
		368	uint64_t ino = 42;
		369	struct flock fl;
		370	int fd;
		371	pid_t pid = 1234;
		372
		373	expect_lookup(RELPATH, ino);
		374	expect_open(ino, 0, 1);
		375	expect_setlk(ino, pid, 10, 1009, F_UNLCK, 0);
		376
		377	fd = open(FULLPATH, O_RDWR);
		378	ASSERT_LE(0, fd) << strerror(errno);
		379	fl.l_start = 10;
		380	fl.l_len = 1000;
		381	fl.l_pid = pid;
		382	fl.l_type = F_UNLCK;
		383	fl.l_whence = SEEK_SET;
		384	fl.l_sysid = 0;
		385	ASSERT_NE(-1, fcntl(fd, F_SETLK, &fl)) << strerror(errno);
		386	leak(fd);
		387	}
		388
346	/* Set a new lock with FUSE_SETLK */	389	/* Set a new lock with FUSE_SETLK */
347	TEST_F(Setlk, set)	390	TEST_F(Setlk, set)
348	{	391	{
Lines 465-471 TEST_F(Setlkw, set) Link Here
465		508
466	expect_lookup(RELPATH, ino);	509	expect_lookup(RELPATH, ino);
467	expect_open(ino, 0, 1);	510	expect_open(ino, 0, 1);
468	expect_setlk(ino, pid, 10, 1009, F_RDLCK, 0);	511	expect_setlkw(ino, pid, 10, 1009, F_RDLCK, 0);
469		512
470	fd = open(FULLPATH, O_RDWR);	513	fd = open(FULLPATH, O_RDWR);
471	ASSERT_LE(0, fd) << strerror(errno);	514	ASSERT_LE(0, fd) << strerror(errno);

Lines 206-211 TEST_F(ReleaseWithLocks, unlock_on_close) Link Here

(-)b/tests/sys/fs/fusefs/release.cc (-2 / +11 lines)
206	ResultOf([=](auto in) {	206	ResultOf([=](auto in) {
207	return (in.header.opcode == FUSE_SETLK &&	207	return (in.header.opcode == FUSE_SETLK &&
208	in.header.nodeid == ino &&	208	in.header.nodeid == ino &&
		209	in.body.setlk.lk.type == F_RDLCK &&
		210	in.body.setlk.fh == FH);
		211	}, Eq(true)),
		212	_)
		213	).WillOnce(Invoke(ReturnErrno(0)));
		214	EXPECT_CALL(*m_mock, process(
		215	ResultOf([=](auto in) {
		216	return (in.header.opcode == FUSE_SETLK &&
		217	in.header.nodeid == ino &&
		218	in.body.setlk.lk.type == F_UNLCK &&
209	in.body.setlk.fh == FH);	219	in.body.setlk.fh == FH);
210	}, Eq(true)),	220	}, Eq(true)),
211	_)	221	_)
Lines 221-227 TEST_F(ReleaseWithLocks, unlock_on_close) Link Here
221	fl.l_type = F_RDLCK;	231	fl.l_type = F_RDLCK;
222	fl.l_whence = SEEK_SET;	232	fl.l_whence = SEEK_SET;
223	fl.l_sysid = 0;	233	fl.l_sysid = 0;
224	ASSERT_NE(-1, fcntl(fd, F_SETLKW, &fl)) << strerror(errno);	234	ASSERT_NE(-1, fcntl(fd, F_SETLK, &fl)) << strerror(errno);
225		235
226	ASSERT_EQ(0, close(fd)) << strerror(errno);	236	ASSERT_EQ(0, close(fd)) << strerror(errno);
227	}	237	}
228	-