Newsgroup: it.comp.os.dibattiti
Titolo: Process Aggregates: module based support for jobs


Subject: Process Aggregates: module based support for jobs
Los Alomos National Laboratory (LANL) and SGI are collaborating
together to provide an accounting solution called Comprehensive System
Accounting (CSA).  CSA is for demanding Linux users who require the
ability to track system resource utilization and charge back the cost
of those resources used to the actual users who consume them.  To
accomplish this task, CSA performs job level accounting, as opposed to
the more familiar process level accounting (for CSA information see,
http://oss.sgi.com/projects/csa
). CSA requires that a job container for
processes be made available on Linux.
A job is defined as a group of related processes, all descended from a
point of entry process and identified by a unique job ID. A job can
contain multiple process groups, session, and processes.  The job acts
as a process containment mechanism and a process is not allowed to
escape from the job container.
[...]
-- 
ciao, |
Marco | "You're one of those condescending Unix computer users!"
      | "Here's a nickel, kid. Get yourself a better computer"  -- Dilbert
      | (Ri)scoprire fidonet: 
http://bbs.mi.linux.it


Era ora che anche Linux avesse il concetto di job.
Saluti.


Era ora che anche w2k avesse il concetto di job.
Linux, ma UNIX in generale, ce l'ha sempre avuto il concetto di
job, tramite i gruppi di processi nel kernel e la shell in userspace.
Questo modulo implementa nel kernel un jid, job id e permette di
impostare delle risorse per essi. Il tutto in 90 righe di codice..
NT e w2k non hanno tutt'ora ne il concetto di gruppi di processi
ne quello di gerarchia dei processi. Almeno da quanto mi hanno detto.
-- 
Lorenzo
"Given enough eyeballs, all bugs are shallow", Linus'Law
(address rot13 encoded)

 Saluti.
[cat@alexandra cat]$ mpg123 ABRAXAS_-_BIG_IN_JAPAN.mp3 
High Performance MPEG 1.0/2.0/2.5 Audio Player for Layer 1, 2 and 3.
Version 0.59r (1999/Jun/15). Written and copyrights by Michael Hipp.
Uses code from various people. See 'README' for more!
THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! USE AT YOUR OWN RISK!
Title  : BIG IN JAPAN                    Artist: ABRAXAS
Album  :                                 Year  : 1984
Comment: 
http://www.vitaminic.it
         Genre : Unknown
Playing MPEG stream from ABRAXAS_-_BIG_IN_JAPAN.mp3 ...
MPEG 1.0 layer III, 128 kbit/s, 44100 Hz joint-stereo
[2]+  Stopped                 mpg123 ABRAXAS_-_BIG_IN_JAPAN.mp3
[cat@alexandra cat]$ exit
exit
There are stopped jobs.
[cat@alexandra cat]$ 
-- 
Davide Inglima, limaCAT
Unix: one of the components of a successful GNU/Emacs operating system.

Era ora che anche Linux avesse il concetto di job.
Era ora? A me non sembra una funzionalita` *cosi`* richiesta fuori
dall'ambiente dei mainframe.


 ne quello di gerarchia dei processi. Almeno da quanto mi hanno detto.
Informati meglio.
Saluti.

 [cat@alexandra cat]$
Leggi meglio il post di Marco.
Saluti.

 dall'ambiente dei mainframe.
E' richiesta ovunque esistano almeno due persone che usano lo stesso host.
Saluti.

E' richiesta ovunque esistano almeno due persone che usano lo stesso host.
Mi dispiace, la realta` contrasta cone le tue impressioni.


 Mi dispiace, la realta` contrasta cone le tue impressioni.
Per te che sei un cesellatore certosino è sufficiente gestire le limitazioni
di uso risorse a livello di singolo processo.
Siccome che nel mondo reale le cose non si fanno con un solo processo ma con
più processi
coordinati fra loro risulta lievemente difficoltoso gestire le limitazioni
su ogni singolo processo.
E' la stessa cosa della gestione delle Acl su base utente o su gruppi di
utenti.
Saluti.


Allora informami, esiste un gid? Come faccio ad ottenerlo?
Esiste un ppid? Come faccio ad ottenerlo?
Voglio vedere le API.


E' richiesta ovunque esistano almeno due persone che usano lo stesso host.
Allora NT non e` multiutente :-)


 Voglio vedere le API.
void StartRestrictedProcess() {
    // Create a job kernel object
    HANDLE hjob = CreateJobObject(NULL, NULL);
    // Place some restrictions on processes in the job
    // First, set some basic restrictions
    JOBOBJECT_BASIC_LIMIT_INFORMATION jobli = { 0 };
    // The process always runs in the idle priority class
    jobli.PriorityClass = IDLE_PRIORITY_CLASS;
    // The job cannot use more than 1 second of CPU time
    jobli.PerJobUserTimeLimit.QuadPart = 10000000;    // 1 second in 100-ns
intervals
    // These are the only 2 restrictions I want placed on the job (process)
    jobli.LimitFlags = JOB_OBJECT_LIMIT_PRIORITY_CLASS |
JOB_OBJECT_LIMIT_JOB_TIME;
    SetInformationJobObject(hjob, JobObjectBasicLimitInformation, &jobli,
sizeof(jobli));
    // Second, set some UI restrictions
    JOBOBJECT_BASIC_UI_RESTRICTIONS jobuir;
    jobuir.UIRestrictionsClass  = JOB_OBJECT_UILIMIT_NONE;    // A fancy 0
    // The process can't logoff the system
    jobuir.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_EXITWINDOWS;
    // The process can't access USER object (like other windows) in the
system
    jobuir.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_HANDLES
    SetInformationJobObject(hjob, JobObjectBasicUIRestrictions, &jobuir,
sizeof(jobuir));
    // Spawn the process that is to be in the job
    // Note: You must first spawn the process and then place the process in
the job.
    //        This means that the process's thread must be initially
suspended so that
    //        it can't execute any code outside of the job's restrictions.
    STARTUPINFO si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    CreateProcess(NULL, "CMD", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL,
NULL, &si, &pi);
    // Place the process in the job.
    // Note: if this process spawns any children, the children are
    //        automatically associated with the same job
    AssignProcessToJobObject(hjob, pi.hProcess);
    // Now, we can allow the child process's thread to execute code.
    ResumeThread(pi.hThread);
    CloseHandle(pi.hThread);
    // Wait for the process to terminate or for all the job's allotted CPU
time to be used
    HANDLE h[2];
    h[0] = pi.hProcess;
    h[1] = hjob;
    DWORD dw = WaitForMultipleObjects(2, h, FALSE, INFINITE);
    switch (dw - WAIT_OBJECT_0) {
        case 0:
            // The process has terminated.
            break;
        case 1:
            // All of the job's allotted CPU time was used.
            break;
    }
    // Clean-up properly
    CloseHandle(pi.hProcess);
    CloseHandle(hjob);
}
void StartRestrictedProcess() {
    // Create a job kernel object
    HANDLE hjob = CreateJobObject(NULL, NULL);
    // Place some restrictions on processes in the job
    // First, set some basic restrictions
    JOBOBJECT_BASIC_LIMIT_INFORMATION jobli = { 0 };
    // The process always runs in the idle priority class
    jobli.PriorityClass = IDLE_PRIORITY_CLASS;
    // The job cannot use more than 1 second of CPU time
    jobli.PerJobUserTimeLimit.QuadPart = 10000000;    // 1 second in 100-ns
intervals
    // These are the only 2 restrictions I want placed on the job (process)
    jobli.LimitFlags = JOB_OBJECT_LIMIT_PRIORITY_CLASS |
JOB_OBJECT_LIMIT_JOB_TIME;
    SetInformationJobObject(hjob, JobObjectBasicLimitInformation, &jobli,
sizeof(jobli));
    // Second, set some UI restrictions
    JOBOBJECT_BASIC_UI_RESTRICTIONS jobuir;
    jobuir.UIRestrictionsClass  = JOB_OBJECT_UILIMIT_NONE;    // A fancy 0
    // The process can't logoff the system
    jobuir.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_EXITWINDOWS;
    // The process can't access USER object (like other windows) in the
system
    jobuir.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_HANDLES
    SetInformationJobObject(hjob, JobObjectBasicUIRestrictions, &jobuir,
sizeof(jobuir));
    // Spawn the process that is to be in the job
    // Note: You must first spawn the process and then place the process in
the job.
    //        This means that the process's thread must be initially
suspended so that
    //        it can't execute any code outside of the job's restrictions.
    STARTUPINFO si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    CreateProcess(NULL, "CMD", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL,
NULL, &si, &pi);
    // Place the process in the job.
    // Note: if this process spawns any children, the children are
    //        automatically associated with the same job
    AssignProcessToJobObject(hjob, pi.hProcess);
    // Now, we can allow the child process's thread to execute code.
    ResumeThread(pi.hThread);
    CloseHandle(pi.hThread);
    // Wait for the process to terminate or for all the job's allotted CPU
time to be used
    HANDLE h[2];
    h[0] = pi.hProcess;
    h[1] = hjob;
    DWORD dw = WaitForMultipleObjects(2, h, FALSE, INFINITE);
    switch (dw - WAIT_OBJECT_0) {
        case 0:
            // The process has terminated.
            break;
        case 1:
            // All of the job's allotted CPU time was used.
            break;
    }
    // Clean-up properly
    CloseHandle(pi.hProcess);
    CloseHandle(hjob);
}
Saluti.

 Allora NT non e` multiutente :-)
Bisogna prima mettersi d'accordo sul termine "multiutente".
La versione W2K implementa gli oggetti Job dato che implementa di serie la
multiutenza a livello desktop.
Saluti.

 Informati meglio.
Infatti, una sana lettura del RK avrei benevoli influssi sulla tua
conoscenza di W2K.
--
Bye
Gianluca Zanelotto
Ducati ST2 "Red Devil"

su ogni singolo processo.
La stragrande maggioranza delle installazioni non ne ha bisogno.


 multiutenza a livello desktop.
No chiarisci la definizione di "multiutente" su w2k visto che quella
adattabile agli UNIX coincide non casualmente con quella comunemente
nota.
-- 
Pierluigi De Rosa (
tho...@durin.khazad-dum.net
).
<<      LINUX: the choice of a GNU generation     >>
<<   For my real address... ask the Balrog.       >>
* Sostenete la Lega per la Soppressione dei Troll *


Allora potresti rispondermi, se l'hai letta.



[...]
Invece di postare codice a caso, che poi e` lo stesso
dell'altra volta, prova a rispondere in modo preciso.
NT e w2k hanno il pid per i processi e per i thread.
Le mie domande erano:
Dove sono i gruppi di processi, il group id?
Dov'e` il parent process id?
Se ho un processo come faccio sapere chi e` il padre?


 Se ho un processo come faccio sapere chi e` il padre?
Non lo sai. Sai quale è il Job al quale appartiene quel processo.
Saluti.
Saluti.

 nota.
E' la stessa.
Saluti.

 La stragrande maggioranza delle installazioni non ne ha bisogno.
E' vero. Come è vero che non si ha (teoricamente) nemmeno
bisogno del concetto di gruppo di utenti per gestire i diritti di accesso
alle risorse.
Solo che il concetto di gruppo è comodo è fa risparmiare tempo.
Saluti.

 E' la stessa.
Allora la tua precedente domanda non ha senso.


 Allora potresti rispondermi, se l'hai letta.
Giusto per iniziare:
http://www.microsoft.com/msj/defaulttop.asp?page=/msj/0399/jobkernelobj/jobk
ernelobjtop.htm


 Solo che il concetto di gruppo è comodo > è  < fa risparmiare tempo.
Orrore!!!!
Saluti.

Sai quale è il Job al quale appartiene quel processo.
E che me ne faccio?
Il fatto e` che di natura sia NT che w2k non tengono traccia
della generazione dei processi, di conseguenza non hanno una
struttura gerarchica dei processi in senso stretto come gli *nix.


dall'ambiente dei mainframe.
Beh, anche sui mid-range...
Obelix

 struttura gerarchica dei processi in senso stretto come gli *nix.
Di natura NT e W2K usano i thread per fare quello che Unix fa con i
processi.
Saluti.

ernelobjtop.htm
Vedi la mia risposta a Gabriele.


processi.
Ma non hai lo stesso una struttura gerarchica dei processi,
ce l'avresti ma a due soli livelli, processo/thread.


 ce l'avresti ma a due soli livelli, processo/thread.
E allora?
Saluti.

E allora?
Te l'ho detto, NT e w2k non hanno una struttura gerarchica dei
processi. Quello che sto cercando di farti capire da 3 mesi :-)


 processi. Quello che sto cercando di farti capire da 3 mesi :-)
Guarda che questo era stato chiarito 3 mesi fa.
Saluti.

 processi. Quello che sto cercando di farti capire da 3 mesi :-)
Questo è stato sempre chiaro.
Sei tu che ancora non capisci a che serve l'oggetto Job.
Saluti.

[cat@alexandra cat]$ 
Non e` quel tipo di job che si intendeva.
-- 
The Hitman - 
http://members.xoom.it/hitman
e-posta : sonicblast (at) 
tiscalinet.it
 
* Un utente normale di PC, quindi tutt'altro *
* che un esperto.                            *

 Non e` quel tipo di job che si intendeva.
The Linux Generation.
Bye.

Sei tu che ancora non capisci a che serve l'oggetto Job.
So a cosa non serve. Non serve a dare una struttura gerarchica
ai processi.
-- 


Preferisco la versione dei Guano Apes :)
Ma l'originale non era degli Alphaville (In concerto a Zurigo !) ?
-- 
                                                                     __
 __                                                              _  ///
| _        Student in Computer Science, Swiss Federal Institute  \\///
|__|iambo      of Technology - mailto:
ggia...@iiic.ethz.ch
       \X/

 Ma l'originale non era degli Alphaville (In concerto a Zurigo !) ?
Raga, qua ogni artista fa un brano con il titolo Big In Japan (formula
della quale si e' gia' discussa proprio qua su icod), anche Tom Waits...
(E se ho sbagliato pure il nome di questo sukate, non ho voglia di
scendere e di andare a guardare sulla scatola di Jesus Blood Never Failed
Me Yet, comprata da un genitore impazzito che prima di allora dava retta
ai "giudizi" di Audio Review).
-- 
Davide Inglima, limaCAT
Unix: one of the components of a successful GNU/Emacs operating system.

 The Linux Generation.
Beh, per lo meno la mia confusione e' stata data da mancata conoscenza dei
fatti, non di certo dalle merendine.


Ma l'originale non era degli Alphaville (In concerto a Zurigo !) ?
Boh,  infatti ho  detto  la "versione"...  l'originale sinceramente  non
saprei di chi e`...
-- 
The Hitman - 
http://members.xoom.it/hitman
 / Un utente qualsiasi di PC
e-posta : sonicblast (at) 
tiscalinet.it
    / Tutt'altro che un esperto 
"Tra gli inferi il dubbio  serpeggia, nessuna beata certezza ne` l'ombra
di pieta ... non pensare che sia distante, da qui vedo la tua casa"

 ai processi.
Ed invece ho scoperto che fa proprio quello.
I padri sanno quali sono i figli. Ed  i figli possono creare Job. Se termini
un Job muoiono i processi contenuti
ed i Job da loro creati.
Saluti.

ed i Job da loro creati.
I processi di un job muoiono tutti assieme solo se chiami
TerminateJobObject().
Se ti limiti a rilasciare l'handle i processi non muoiono.
In ogni caso non vedo cosa c'entri questo con la gerarchia
dei processi.
