title: setrlimit fails with Operation not permitted when run under valgrind
body: <p>I may be missing something or may be not but the <code>setrlimit</code> function is failing consistently when run under valgrind</p>
  
  <pre><code>int main()
  {
          const struct rlimit file_limits = { .rlim_cur = 65536, .rlim_max = 65536 };
          if ( setrlimit( RLIMIT_NOFILE, &amp;file_limits ) )
          {
                  printf(" Failed  %d", errno );
                  perror(" More " );
          }
          else
          {
                  printf(" Success ");
          }
          printf("\n");
          return 0;
  }
  </code></pre>
  
  <h3>Here are the sample runs</h3>
  
  <p>Normal run</p>
  
  <pre><code>sh-4.2# ulimit -H -n
  800000
  sh-4.2# ulimit -S -n
  500000
  sh-4.2# ./rlimit
   Success
  sh-4.2#
  </code></pre>
  
  <p>under valgrind</p>
  
  <pre><code>sh-4.2#
  sh-4.2# valgrind ./rlimit
  ==28974== Memcheck, a memory error detector
  ==28974== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
  ==28974== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
  ==28974== Command: ./rlimit
  ==28974==
   More : Operation not permitted
   Failed  1
  ==28974==
  ==28974== HEAP SUMMARY:
  ==28974==     in use at exit: 0 bytes in 0 blocks
  ==28974==   total heap usage: 1 allocs, 1 frees, 568 bytes allocated
  ==28974==
  ==28974== All heap blocks were freed -- no leaks are possible
  ==28974==
  ==28974== For counts of detected and suppressed errors, rerun with: -v
  ==28974== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
  sh-4.2#
  </code></pre>
  
  <p>Any hints on this would be great. <strong>NOTE:</strong> this is on CentOS release 7.4 (Final).</p>
  
  <h3>Edits #1</h3>
  
  <p>With minimal working code:</p>
  
  <pre><code>int main()
  {
          const struct rlimit file_limits = { .rlim_cur = 65536, .rlim_max = 65536 };
          setrlimit( RLIMIT_NOFILE, &amp;file_limits ) ;
          perror(" wrong ?? " );
          printf("\n");
          return 0;
  }
  </code></pre>
  
  <p>corresponding outputs:</p>
  
  <pre><code>[root@localhost kk]# valgrind ./rlimit
  ==29179== Memcheck, a memory error detector
  ==29179== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
  ==29179== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
  ==29179== Command: ./rlimit
  ==29179==
   wrong ?? : Operation not permitted
  
  ==29179==
  ==29179== HEAP SUMMARY:
  ==29179==     in use at exit: 0 bytes in 0 blocks
  ==29179==   total heap usage: 1 allocs, 1 frees, 568 bytes allocated
  ==29179==
  ==29179== All heap blocks were freed -- no leaks are possible
  ==29179==
  ==29179== For counts of detected and suppressed errors, rerun with: -v
  ==29179== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
  [root@localhost kk]# ./rlimit
   wrong ?? : Success
  </code></pre>
  
  <p>this <strong>wrong ?? : Operation not permitted</strong> is driving me crazy :(</p>
  
  <h3>Edit #2</h3>
  
  <p>So based on some suggestion I tried to retrieve existing limits and see if there is something wrong with that, turns out the behavior beyond my comprehension</p>
  
  <pre><code>int main()
  {
          const struct rlimit file_limits = { .rlim_cur = 65536, .rlim_max = 65536 };
          struct rlimit limit;
          getrlimit(RLIMIT_NOFILE,&amp;limit);
          printf("%d \n",limit.rlim_max);
  
          setrlimit( RLIMIT_NOFILE, &amp;file_limits ) ;
          perror(" wrong ?? " );
          printf("\n");
  
          getrlimit(RLIMIT_NOFILE,&amp;limit);
          printf("%d \n",limit.rlim_max);
          return 0;
  }
  </code></pre>
  
  <p>1st run, the limit is set to 65590 and the executable is able to alter the limits to 65536, viz is expected</p>
  
  <pre><code>[root@localhost kk]# ulimit -n
  65590
  [root@localhost kk]# ./rlimit
  65590
   wrong ?? : Success
  
  65536
  [root@localhost kk]#
  </code></pre>
  
  <p>2nd run, under valgrind</p>
  
  <pre><code>[root@localhost kk]# ulimit -n
  65590
  [root@localhost kk]# valgrind ./rlimit
  ==17595== Memcheck, a memory error detector
  ==17595== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
  ==17595== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
  ==17595== Command: ./rlimit
  ==17595==
  65578
   wrong ?? : Operation not permitted
  
  65578
  ==17595==
  ==17595== HEAP SUMMARY:
  ==17595==     in use at exit: 0 bytes in 0 blocks
  ==17595==   total heap usage: 1 allocs, 1 frees, 568 bytes allocated
  ==17595==
  ==17595== All heap blocks were freed -- no leaks are possible
  ==17595==
  ==17595== For counts of detected and suppressed errors, rerun with: -v
  ==17595== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
  [root@localhost kk]#
  </code></pre>
  
  <p>I'm probably inclined to say that may be valgrind reserves a few files descriptors for its use <a href="https://sourceforge.net/p/valgrind/mailman/message/32904445/" rel="noreferrer">based on discussion here</a> let's say in this case it 12?? Thus setting the limit to 65578?? Which is still more that what the program is trying to reserve 65536.</p>
  
  <p>Any more suggestions to follow?</p>