Differential D23566 Diff 64942 processcore/process_controller.h

Changeset View

Standalone View

View Options

processcore/process_controller.h

  • This file was added.
1​/*
2​ * This file is part of KSysGuard.
3​ * Copyright 2019 Arjen Hiemstra <ahiemstra@heimr.nl>
4​ *
5​ * This program is free software; you can redistribute it and/or
6​ * modify it under the terms of the GNU General Public License as
7​ * published by the Free Software Foundation; either version 2 of
8​ * the License or (at your option) version 3 or any later version
9​ * accepted by the membership of KDE e.V. (or its successor approved
10​ * by the membership of KDE e.V.), which shall act as a proxy
11​ * defined in Section 14 of version 3 of the license.
12​ *
13​ * This program is distributed in the hope that it will be useful,
14​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16​ * GNU General Public License for more details.
17​ *
18​ * You should have received a copy of the GNU General Public License
19​ * along with this program. If not, see <http://www.gnu.org/licenses/>.
20​ */
21​
22​#ifndef KSYSGUARD_PROCESSCONTROLLER_H
23​#define KSYSGUARD_PROCESSCONTROLLER_H
24​
25​#include <memory>
26​
27​#include <QObject>
28​
29​#include "process.h"
30​
31​class QWidget;
32​
33​/**
34​ * Control processes' priority, scheduling and sending signals.
35​ *
36​ * This class contains methods for sending signals to processes, setting their
37​ * priority and setting their scheduler. It will first try to manipulate the
38​ * processes directly, if that fails, it will use KAuth to try and perform the
39​ * action as root.
40​ */
41​namespace KSysGuard {
42​
43​class Q_DECL_EXPORT ProcessController : public QObject
44​{
45​ Q_OBJECT
46​
47​public:
48​ ProcessController(QObject* parent = nullptr);
49​ ~ProcessController();
50​
51​ /**
52​ * A signal that can be sent to a process.
53​ */
54​ enum Signal {
55​ StopSignal,
56​ ContinueSignal,
57​ HangupSignal,
58​ InterruptSignal,
59​ TerminateSignal,
60​ KillSignal,
61​ User1Signal,
62​ User2Signal
63​ };
64​ Q_ENUM(Signal)
65​
66​ /**
67​ * What kind of result a call to one of the ProcessController methods had.
68​ */
69​ enum class Result {
70​ Unknown, ///< Something happened, we just do not know what.
71​ Success, ///< Everything went alright.
72​ InsufficientPermissions, ///< Some processes require privileges to modify and we failed getting those.
73​ NoSuchProcess, ///< Tried to modify a process that no longer exists.
74​ Unsupported, ///< The specified action is not supported.
75​ UserCancelled, ///< The user cancelled the action, usually when requesting privileges.
76​ Error, ///< An error occurred when requesting privileges.
77​ };
78​ Q_ENUM(Result)
79​
80​ /**
81​ * The widget used as parent for any dialogs that get shown.
82​ */
83​ QWidget *widget() const;
84​ /**
85​ * Set the widget to use as parent for dialogs.
86​ *
87​ * \param widget The widget to use.
88​ */
89​ void setWidget(QWidget *widget);
davidedmundsonUnsubmitted
Not Done

Eww, it would be better if we could make this a qwindow, but I see you're limited by current KAuth

davidedmundson: Eww, it would be better if we could make this a qwindow, but I see you're limited by current…
ahiemstraAuthorUnsubmitted
Not Done

Agreed. I did look at what would be needed to do that, but the entire widget thing is embedded pretty deeply in KAuth. Luckily, for QML we can probably just leave this out. We won't get window modality, but that's the only drawback. I added this mostly so we don't have any regressions in the current UI.

ahiemstra: Agreed. I did look at what would be needed to do that, but the entire widget thing is embedded…
90​
91​ /**
92​ * Send a signal to a number of processes.
93​ *
94​ * This will send \p signal to all processes in \p pids. Should a number of
95​ * these be owned by different users, an attempt will be made to send the
96​ * signal as root using KAuth.
97​ *
98​ * \param pids A vector of pids to send the signal to.
99​ * \param signal The signal to send. See Signal for possible values.
100​ *
101​ * \return A Result value that indicates whether the action succeeded. Note
102​ * that a non-Success result may indicate any of the processes in
103​ * \p pids encountered that result.
104​ */
105​ Q_INVOKABLE Result sendSignal(const QVector<int> &pids, int signal);
106​ /**
107​ * \overload Result sendSignal(const QVector<int> &pids, int signal)
108​ */
109​ Q_INVOKABLE Result sendSignal(const QList<long long> &pids, int signal);
110​
111​ /**
112​ * Set the priority (niceness) of a number of processes.
113​ *
114​ * This will set the priority of all processes in \p pids to \p priority.
115​ * Should a number of these be owned by different users, an attempt will be
116​ * made to send the signal as root using KAuth.
117​ *
118​ * \param pids A vector of pids to set the priority of.
119​ * \param priority The priority to set. Lower means higher priority.
120​ *
121​ * \return A Result value that indicates whether the action succeeded. Note
122​ * that a non-Success result may indicate any of the processes in
123​ * \p pids encountered that result.
124​ */
125​ Q_INVOKABLE Result setPriority(const QVector<int> &pids, int priority);
126​ /**
127​ * \overload Result setPriority(const QVector<int> &pids, int priority)
128​ */
129​ Q_INVOKABLE Result setPriority(const QList<long long> &pids, int priority);
130​
131​ /**
132​ * Set the CPU scheduling policy and priority of a number of processes.
133​ *
134​ * This will set the CPU scheduling policy and priority of all processes in
135​ * \p pids to \p scheduler and \p priority. Should a number of these be
136​ * owned by different users, an attempt will be made to send the signal as
137​ * root using KAuth.
138​ *
139​ * \param pids A vector of pids to set the scheduler of.
140​ * \param scheduler The scheduling policy to use.
141​ * \param priority The priority to set. Lower means higher priority.
142​ *
143​ * \return A Result value that indicates whether the action succeeded. Note
144​ * that a non-Success result may indicate any of the processes in
145​ * \p pids encountered that result.
146​ */
147​ Q_INVOKABLE Result setCPUScheduler(const QVector<int> &pids, Process::Scheduler scheduler, int priority);
148​ /**
149​ * \overload Result setCPUScheduler(const QVector<int> &pids, Process::Scheduler scheduler, int priority)
150​ */
151​ Q_INVOKABLE Result setCPUScheduler(const QList<long long> &pids, Process::Scheduler scheduler, int priority);
152​
153​ /**
154​ * Set the IO scheduling policy and priority of a number of processes.
155​ *
156​ * This will set the IO scheduling policy and priority of all processes in
157​ * \p pids to \p priorityClass and \p priority. Should a number of these be
158​ * owned by different users, an attempt will be made to send the signal as
159​ * root using KAuth.
160​ *
161​ * \param pids A vector of pids to set the scheduler of.
162​ * \param priorityClass The scheduling policy to use.
163​ * \param priority The priority to set. Lower means higher priority.
164​ *
165​ * \return A Result value that indicates whether the action succeeded. Note
166​ * that a non-Success result may indicate any of the processes in
167​ * \p pids encountered that result.
168​ */
169​ Q_INVOKABLE Result setIOScheduler(const QVector<int> &pids, Process::IoPriorityClass priorityClass, int priority);
170​ /**
171​ * \overload Result setIOScheduler(const QVector<int> &pids, Process::IoPriorityClass priorityClass, int priority)
172​ */
173​ Q_INVOKABLE Result setIOScheduler(const QList<long long> &pids, Process::IoPriorityClass priorityClass, int priority);
174​
175​private:
176​ class Private;
177​ const std::unique_ptr<Private> d;
178​};
179​
180​}
181​
182​#endif // KSYSGUARD_PROCESSCONTROLLER_H