Now this test program hangs on latest git.
Thanks,
Miklos
---
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
int res;
char *name = argv[1];
int fd;
unlink(name);
fd = creat(name, 0644);
write(fd, "123", 3);
close(fd);
close(open(name, O_RDONLY | O_TRUNC));
return 0;
}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"Myklebust, Trond" <[email protected]> writes:
> Hi Miklos
>
> On Fri, 2012-04-06 at 11:43 +0200, Miklos Szeredi wrote:
>> "Myklebust, Trond" <[email protected]> writes:
>>
>> > The following client patch fixes the regression for me.
>>
>> It fixes the hang, but it still doesn't work 100% correctly. Try the
>> following test program.
>>
>> BTW, do you run any fs test suits? All these were caught with one I use
>> to quick test fuse (it's in the fuse git tree(*) under the "test"
>> directory). But I guess others like LTP would catch these as well.
>
> Thanks! I'll look into that. Bryan has been helping me to set up a test
> rig for the NFS client, but for now we don't have much coverage of basic
> POSIX tests.
>
>> Thanks,
>> Miklos
>>
>> (*) git://fuse.git.sourceforge.net/gitroot/fuse/fuse
>> ---
>>
>> #include <stdio.h>
>> #include <unistd.h>
>> #include <fcntl.h>
>> #include <errno.h>
>>
>> int main(int argc, char *argv[])
>> {
>> int res;
>> char *name = argv[1];
>>
>> unlink(name);
>> close(creat(name, 0400));
>> res = open(name, O_RDONLY | O_TRUNC);
>> if (res != -1 && errno != EPERM)
>> fprintf(stderr, "should have failed!\n");
>
> Shouldn't that be EACCES? As far as I know, POSIX doesn't list EPERM as
> an allowed return value for open().
Yes it should be EACCESS. That test is broken, it should be:
if (res != -1 || errno != EACCES)
The one in the fuse tree is correct though...
Thanks,
Miklos
"Myklebust, Trond" <[email protected]> writes:
> The following client patch fixes the regression for me.
It fixes the hang, but it still doesn't work 100% correctly. Try the
following test program.
BTW, do you run any fs test suits? All these were caught with one I use
to quick test fuse (it's in the fuse git tree(*) under the "test"
directory). But I guess others like LTP would catch these as well.
Thanks,
Miklos
(*) git://fuse.git.sourceforge.net/gitroot/fuse/fuse
---
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
int res;
char *name = argv[1];
unlink(name);
close(creat(name, 0400));
res = open(name, O_RDONLY | O_TRUNC);
if (res != -1 && errno != EPERM)
fprintf(stderr, "should have failed!\n");
return 0;
}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