Linux设置优先级功能在我的测试中没有生效

Question

一段非常简单的测试代码:

#include<unistd.h>
#include<sys/resource.h>
#include<sys/syscall.h>
#include<sys/types.h>
#include<stdio.h>
int main()
{
    int i=0;
    pid_t pid=getpid();
    pid_t tid=syscall(SYS_gettid);
    printf("%d,%d\n",pid,tid);
    setpriority(PRIO_PROCESS,0,-2);
    while(true){
        ++i;
    }
    return 0;
}

setpriority 使用 '0' 作为第二个参数，表示当前进程，根据手册页:

   The  value  which  is one of PRIO_PROCESS, PRIO_PGRP, or PRIO_USER, and
   who  is  interpreted  relative  to  which  (a  process  identifier  for
   PRIO_PROCESS, process group identifier for PRIO_PGRP, and a user ID for
   PRIO_USER).  A zero value for who denotes  (respectively)  the  calling
   process,  the process group of the calling process, or the real user ID
   of the calling process.  Prio is a value in the range -20  to  19  (but
   see  the  Notes  below).   The  default priority is 0; lower priorities
   cause more favorable scheduling.

编译运行，在“top”命令中，“a.out”的“PR”值仍然是20，没有像我预期的那样设置为“20-2”。

我的“setpriority”生效了吗？

Answer 1

我的第一个建议是检查 setpriority() 的返回值查看它是否返回错误。我的期望是它通过返回 -1 来指示错误然后检查errno会揭示EACCES是表明调用者没有所需权限的错误。

解决这个问题的三种方法:

1) 将可执行文件设为 SUID root 或使用 sudo 运行(不安全)。

2) 授予可执行文件能力 CAP_SYS_NICE (例如 sudo setcap cap_sys_nice=ep <executable> )。

3) 调整 shell ( ulimit ) 或用户(取决于发行版 /etc/security/limits.conf )的硬限制和软限制。或者只调整硬限制，让程序调整软限制。

请注意，SUID 和文件功能对使用 nosuid 挂载的分区无效(加密的主目录通常是)。

编辑:@TrentP 指出您可以放弃特权。下面是一些代码，是如何执行此操作的一个很好的示例，尽管它适用于实时优先级:

/*
 * Set_policy_priority
 *
 * This is used to set the priority and policy for the real-time
 * scheduler.  This normally requires some form of privilege, as the
 * default hard ulimit of 0 will prevent an unprivileged program from
 * doing so.
 *
 * The most secure thing to do is grant the executable the potential
 * to enable CAP_SYS_RESOURCE (with sudo setcap cap_sys_resource=p
 * <executable>).  If it is needed, this routine will enable the
 * capability, raise the hard limit, and then irrevocably drop the
 * privilege.
 *
 */

int set_policy_priority(int policy, int priority, int nofiles) {
  const cap_value_t cap_vector[1] = { CAP_SYS_RESOURCE };
  cap_t privilege_dropped = cap_init();
  cap_t privilege_off = cap_dup(privilege_dropped);
  cap_set_flag(privilege_off, CAP_PERMITTED, 1, cap_vector, CAP_SET);
  cap_t privilege_on = cap_dup(privilege_off);
  cap_set_flag(privilege_on, CAP_EFFECTIVE, 1, cap_vector, CAP_SET);

  struct sched_param param;
  struct rlimit rl;
  int e, min, max;

  // See if priority we want is in the range offered by SCHED_FIFO

  min = sched_get_priority_min(policy);
  max = sched_get_priority_max(policy);
  if (verbose) {
fprintf(stderr, "For policy SCHED_FIFO min priority is %d, max is %d.\n", min, max);
  }

  if ((min>priority)||(max<priority)) {
fprintf(stderr, "Desired priority of %d is out of range.\n", priority);
return 1;
  }

  // See if the RTPRIO limits allows the priority we want

  if (getrlimit(RLIMIT_RTPRIO, &rl) != 0) {
e = errno;
fprintf(stderr, "Failed to getrlimit(): %s.\n", strerror(e));
return 1;
  }

  if (verbose) {
fprintf(stderr, "RTPRIO soft limit is %d, hard is %d.\n", 
    (int) rl.rlim_cur, (int) rl.rlim_max);
  }

  // Adjust hard limit if necessary

  if (rl.rlim_max < priority) {
if (cap_set_proc(privilege_on) != 0) {
  fprintf(stderr, "Need to raise RTPRIO hard limit, but can't enable CAP_SYS_RESOURCE.\n");
  return 1;
}
rl.rlim_max = priority;
if (setrlimit(RLIMIT_RTPRIO, &rl) != 0) {
  e = errno;
  fprintf(stderr, "Failed to raise hard limit for RTPRIO to %d: %s.\n", 
     (int) rl.rlim_max, strerror(e));
  return 1;
}
if (cap_set_proc(privilege_off)) {
  fprintf(stderr, "Failed to turn off privileges.\n");
  return 1;
}
if (verbose) {
  printf("Raised hard limit for RTPRIO to %d.\n", (int) rl.rlim_max);
}
  }

  // Adjust soft limit if necessary

  if (rl.rlim_cur < priority) {
rl.rlim_cur = priority;
if (setrlimit(RLIMIT_RTPRIO, &rl) != 0) {
  e = errno;
  fprintf(stderr, "Failed to raise soft limit for RTPRIO to %d: %s.\n", 
     (int) rl.rlim_cur, strerror(e));
  return 1;
}
if (verbose) {
  printf("Raised soft limit for RTPRIO to %d.\n", (int) rl.rlim_cur);
}
  }

  // Set desired priority with class SCHED_FIFO

  param.sched_priority = priority;
  if (sched_setscheduler(0, policy, &param) != 0) {
e = errno;
fprintf(stderr, "Setting policy failed: %s.\n", strerror(e));
return 1;
  } else if (verbose) {
printf("Set policy SCHED_FIFO, priority %d.\n", param.sched_priority);
  }

  // See if the NOFILE limits allows the number of fds we want

  if (getrlimit(RLIMIT_NOFILE, &rl) != 0) {
e = errno;
fprintf(stderr, "Failed to getrlimit(): %s.\n", strerror(e));
return 1;
  }

  if (verbose) {
fprintf(stderr, "NOFILE soft limit is %d, hard is %d.\n", 
    (int) rl.rlim_cur, (int) rl.rlim_max);
  }

  // Adjust hard limit if necessary

  if (rl.rlim_max < nofiles) {
if (cap_set_proc(privilege_on) != 0) {
  fprintf(stderr, "Need to raise NOFILE hard limit, but can't enable CAP_SYS_RESOURCE.\n");
  return 1;
}
rl.rlim_max = nofiles;
if (setrlimit(RLIMIT_NOFILE, &rl) != 0) {
  e = errno;
  fprintf(stderr, "Failed to raise hard limit for NOFILE to %d: %s.\n", 
     (int) rl.rlim_max, strerror(e));
  return 1;
}
if (cap_set_proc(privilege_off)) {
  fprintf(stderr, "Failed to turn off privileges.\n");
  return 1;
}
if (verbose) {
  printf("Raised hard limit for NOFILE to %d.\n", (int) rl.rlim_max);
}
  }

  // Adjust soft limit if necessary

  if (rl.rlim_cur < nofiles) {
rl.rlim_cur = nofiles;
if (setrlimit(RLIMIT_NOFILE, &rl) != 0) {
  e = errno;
  fprintf(stderr, "Failed to raise soft limit for NOFILE to %d: %s.\n", 
     (int) rl.rlim_cur, strerror(e));
  return 1;
}
if (verbose) {
  printf("Raised soft limit for NOFILE to %d.\n", (int) rl.rlim_cur);
}
  }

  if (cap_set_proc(privilege_dropped)) {
fprintf(stderr, "Failed to turn irrevocably drop privileges.\n");
return 1;
  }

  return 0;
}