1/**
2 * D header file for POSIX.
3 *
4 * Copyright: Copyright (c) 2013 Lars Tandle Kyllingstad.
5 * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6 * Authors:   Lars Tandle Kyllingstad
7 * Standards: The Open Group Base Specifications Issue 7, IEEE Std 1003.1-2008
8 */
9module core.sys.posix.sys.resource;
10version (Posix):
11
12public import core.sys.posix.sys.time;
13public import core.sys.posix.sys.types: id_t;
14import core.sys.posix.config;
15
16version (OSX)
17    version = Darwin;
18else version (iOS)
19    version = Darwin;
20else version (TVOS)
21    version = Darwin;
22else version (WatchOS)
23    version = Darwin;
24
25nothrow @nogc extern(C):
26@system:
27
28//
29// XOpen (XSI)
30//
31// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_resource.h.html
32/*
33enum
34{
35    PRIO_PROCESS,
36    PRIO_PGRP,
37    PRIO_USER,
38}
39
40alias ulong rlim_t;
41
42enum
43{
44    RLIM_INFINITY,
45    RLIM_SAVED_MAX,
46    RLIM_SAVED_CUR,
47}
48
49enum
50{
51    RUSAGE_SELF,
52    RUSAGE_CHILDREN,
53}
54
55struct rusage
56{
57    timeval ru_utime;
58    timeval ru_stime;
59}
60
61enum
62{
63    RLIMIT_CORE,
64    RLIMIT_CPU,
65    RLIMIT_DATA,
66    RLIMIT_FSIZE,
67    RLIMIT_NOFILE,
68    RLIMIT_STACK,
69    RLIMIT_AS,
70}
71*/
72
73version (linux)
74{
75    enum
76    {
77        PRIO_PROCESS = 0,
78        PRIO_PGRP    = 1,
79        PRIO_USER    = 2,
80    }
81
82    static if (__USE_FILE_OFFSET64)
83         alias ulong rlim_t;
84    else
85         alias c_ulong rlim_t;
86
87    static if (__USE_FILE_OFFSET64)
88        enum RLIM_INFINITY = 0xffffffffffffffffUL;
89    else
90        enum RLIM_INFINITY = cast(c_ulong)(~0UL);
91
92    enum RLIM_SAVED_MAX = RLIM_INFINITY;
93    enum RLIM_SAVED_CUR = RLIM_INFINITY;
94
95    enum
96    {
97        RUSAGE_SELF     =  0,
98        RUSAGE_CHILDREN = -1,
99        RUSAGE_THREAD = 1
100    }
101
102    struct rusage
103    {
104        timeval ru_utime;
105        timeval ru_stime;
106        c_long ru_maxrss;
107        c_long ru_ixrss;
108        c_long ru_idrss;
109        c_long ru_isrss;
110        c_long ru_minflt;
111        c_long ru_majflt;
112        c_long ru_nswap;
113        c_long ru_inblock;
114        c_long ru_oublock;
115        c_long ru_msgsnd;
116        c_long ru_msgrcv;
117        c_long ru_nsignals;
118        c_long ru_nvcsw;
119        c_long ru_nivcsw;
120        version (CRuntime_Musl)
121            c_long[16] __reserved;
122    }
123
124    enum
125    {
126        RLIMIT_CORE   = 4,
127        RLIMIT_CPU    = 0,
128        RLIMIT_DATA   = 2,
129        RLIMIT_FSIZE  = 1,
130        RLIMIT_NOFILE = 7,
131        RLIMIT_STACK  = 3,
132        RLIMIT_AS     = 9,
133    }
134}
135else version (Darwin)
136{
137    enum
138    {
139        PRIO_PROCESS = 0,
140        PRIO_PGRP    = 1,
141        PRIO_USER    = 2,
142    }
143
144    alias ulong rlim_t;
145
146    enum
147    {
148        RLIM_INFINITY  = ((cast(ulong) 1 << 63) - 1),
149        RLIM_SAVED_MAX = RLIM_INFINITY,
150        RLIM_SAVED_CUR = RLIM_INFINITY,
151    }
152
153    enum
154    {
155        RUSAGE_SELF     =  0,
156        RUSAGE_CHILDREN = -1,
157    }
158
159    struct rusage
160    {
161        timeval ru_utime;
162        timeval ru_stime;
163        c_long[14] ru_opaque;
164    }
165
166    enum
167    {
168        RLIMIT_CORE   = 4,
169        RLIMIT_CPU    = 0,
170        RLIMIT_DATA   = 2,
171        RLIMIT_FSIZE  = 1,
172        RLIMIT_NOFILE = 8,
173        RLIMIT_STACK  = 3,
174        RLIMIT_AS     = 5,
175    }
176}
177else version (FreeBSD)
178{
179    enum
180    {
181        PRIO_PROCESS = 0,
182        PRIO_PGRP    = 1,
183        PRIO_USER    = 2,
184    }
185
186    alias long rlim_t;
187
188    enum
189    {
190        RLIM_INFINITY   = (cast(rlim_t)((cast(ulong) 1 << 63) - 1)),
191        RLIM_SAVED_MAX  = RLIM_INFINITY,
192        RLIM_SAVED_CUR  = RLIM_INFINITY,
193    }
194
195    enum
196    {
197        RUSAGE_SELF     =  0,
198        RUSAGE_CHILDREN = -1,
199    }
200
201    struct rusage
202    {
203        timeval ru_utime;
204        timeval ru_stime;
205        c_long ru_maxrss;
206        alias ru_ixrss ru_first;
207        c_long ru_ixrss;
208        c_long ru_idrss;
209        c_long ru_isrss;
210        c_long ru_minflt;
211        c_long ru_majflt;
212        c_long ru_nswap;
213        c_long ru_inblock;
214        c_long ru_oublock;
215        c_long ru_msgsnd;
216        c_long ru_msgrcv;
217        c_long ru_nsignals;
218        c_long ru_nvcsw;
219        c_long ru_nivcsw;
220        alias ru_nivcsw ru_last;
221    }
222
223    enum
224    {
225        RLIMIT_CORE   =  4,
226        RLIMIT_CPU    =  0,
227        RLIMIT_DATA   =  2,
228        RLIMIT_FSIZE  =  1,
229        RLIMIT_NOFILE =  8,
230        RLIMIT_STACK  =  3,
231        RLIMIT_AS     = 10,
232    }
233}
234else version (NetBSD)
235{
236    enum
237    {
238        PRIO_PROCESS = 0,
239        PRIO_PGRP    = 1,
240        PRIO_USER    = 2,
241    }
242
243    alias long rlim_t;
244
245    enum
246    {
247        RLIM_INFINITY   = (cast(rlim_t)((cast(ulong) 1 << 63) - 1)),
248        RLIM_SAVED_MAX = RLIM_INFINITY,
249        RLIM_SAVED_CUR = RLIM_INFINITY,
250    }
251
252    enum
253    {
254        RUSAGE_SELF     =  0,
255        RUSAGE_CHILDREN = -1,
256    }
257
258    struct rusage
259    {
260        timeval ru_utime;
261        timeval ru_stime;
262        c_long ru_maxrss;
263        alias ru_ixrss ru_first;
264        c_long ru_ixrss;
265        c_long ru_idrss;
266        c_long ru_isrss;
267        c_long ru_minflt;
268        c_long ru_majflt;
269        c_long ru_nswap;
270        c_long ru_inblock;
271        c_long ru_oublock;
272        c_long ru_msgsnd;
273        c_long ru_msgrcv;
274        c_long ru_nsignals;
275        c_long ru_nvcsw;
276        c_long ru_nivcsw;
277        alias ru_nivcsw ru_last;
278    }
279
280    enum
281    {
282        RLIMIT_CORE   =  4,
283        RLIMIT_CPU    =  0,
284        RLIMIT_DATA   =  2,
285        RLIMIT_FSIZE  =  1,
286        RLIMIT_NOFILE =  8,
287        RLIMIT_STACK  =  3,
288        RLIMIT_AS     = 10,
289    }
290}
291else version (OpenBSD)
292{
293    enum
294    {
295        PRIO_PROCESS = 0,
296        PRIO_PGRP    = 1,
297        PRIO_USER    = 2,
298    }
299
300    alias ulong rlim_t;
301
302    enum
303    {
304        RLIM_INFINITY  = (cast(rlim_t)((cast(ulong) 1 << 63) - 1)),
305        RLIM_SAVED_MAX = RLIM_INFINITY,
306        RLIM_SAVED_CUR = RLIM_INFINITY,
307    }
308
309    enum
310    {
311        RUSAGE_SELF     =  0,
312        RUSAGE_CHILDREN = -1,
313        RUSAGE_THREAD   =  1,
314    }
315
316    struct rusage
317    {
318        timeval ru_utime;
319        timeval ru_stime;
320        c_long ru_maxrss;
321        alias ru_ixrss ru_first;
322        c_long ru_ixrss;
323        c_long ru_idrss;
324        c_long ru_isrss;
325        c_long ru_minflt;
326        c_long ru_majflt;
327        c_long ru_nswap;
328        c_long ru_inblock;
329        c_long ru_oublock;
330        c_long ru_msgsnd;
331        c_long ru_msgrcv;
332        c_long ru_nsignals;
333        c_long ru_nvcsw;
334        c_long ru_nivcsw;
335        alias ru_nivcsw ru_last;
336    }
337
338    enum
339    {
340        RLIMIT_CORE   =  4,
341        RLIMIT_CPU    =  0,
342        RLIMIT_DATA   =  2,
343        RLIMIT_FSIZE  =  1,
344        RLIMIT_NOFILE =  8,
345        RLIMIT_STACK  =  3,
346        // OpenBSD does not define the following:
347        //RLIMIT_AS,
348    }
349}
350else version (DragonFlyBSD)
351{
352    enum
353    {
354        PRIO_PROCESS = 0,
355        PRIO_PGRP    = 1,
356        PRIO_USER    = 2,
357    }
358
359    alias long rlim_t;
360
361    enum
362    {
363        RLIM_INFINITY   = (cast(rlim_t)((cast(ulong) 1 << 63) - 1)),
364        RLIM_SAVED_MAX  = RLIM_INFINITY,
365        RLIM_SAVED_CUR  = RLIM_INFINITY,
366    }
367
368    enum
369    {
370        RUSAGE_SELF     =  0,
371        RUSAGE_CHILDREN = -1,
372    }
373
374    struct rusage
375    {
376        timeval ru_utime;
377        timeval ru_stime;
378        c_long ru_maxrss;
379        alias ru_ixrss ru_first;
380        c_long ru_ixrss;
381        c_long ru_idrss;
382        c_long ru_isrss;
383        c_long ru_minflt;
384        c_long ru_majflt;
385        c_long ru_nswap;
386        c_long ru_inblock;
387        c_long ru_oublock;
388        c_long ru_msgsnd;
389        c_long ru_msgrcv;
390        c_long ru_nsignals;
391        c_long ru_nvcsw;
392        c_long ru_nivcsw;
393        alias ru_nivcsw ru_last;
394    }
395
396    enum
397    {
398        RLIMIT_CORE   =  4,
399        RLIMIT_CPU    =  0,
400        RLIMIT_DATA   =  2,
401        RLIMIT_FSIZE  =  1,
402        RLIMIT_NOFILE =  8,
403        RLIMIT_STACK  =  3,
404        RLIMIT_AS     = 10,
405    }
406}
407else version (Solaris)
408{
409    enum
410    {
411        PRIO_PROCESS = 0,
412        PRIO_PGRP    = 1,
413        PRIO_USER    = 2,
414    }
415
416    alias c_ulong rlim_t;
417
418    enum : c_long
419    {
420        RLIM_INFINITY   = -3,
421        RLIM_SAVED_MAX  = -2,
422        RLIM_SAVED_CUR  = -1,
423    }
424
425    enum
426    {
427        RUSAGE_SELF     =  0,
428        RUSAGE_CHILDREN = -1,
429    }
430
431    struct rusage
432    {
433        timeval ru_utime;
434        timeval ru_stime;
435        c_long ru_maxrss;
436        c_long ru_ixrss;
437        c_long ru_idrss;
438        c_long ru_isrss;
439        c_long ru_minflt;
440        c_long ru_majflt;
441        c_long ru_nswap;
442        c_long ru_inblock;
443        c_long ru_oublock;
444        c_long ru_msgsnd;
445        c_long ru_msgrcv;
446        c_long ru_nsignals;
447        c_long ru_nvcsw;
448        c_long ru_nivcsw;
449    }
450
451    enum
452    {
453        RLIMIT_CORE   = 4,
454        RLIMIT_CPU    = 0,
455        RLIMIT_DATA   = 2,
456        RLIMIT_FSIZE  = 1,
457        RLIMIT_NOFILE = 5,
458        RLIMIT_STACK  = 3,
459        RLIMIT_AS     = 6,
460    }
461}
462else
463    static assert (false, "Unsupported platform");
464
465/*
466struct rlimit
467{
468    rlim_t rlim_cur;
469    rlim_t rlim_max;
470}
471
472int getpriority(int, id_t);
473int getrlimit(int, rlimit*);
474int getrusage(int, rusage*);
475int setpriority(int, id_t, int);
476int setrlimit(int, const rlimit*);
477*/
478
479struct rlimit
480{
481    rlim_t rlim_cur;
482    rlim_t rlim_max;
483}
484
485version (CRuntime_Glibc)
486{
487    int getpriority(int, id_t);
488    int setpriority(int, id_t, int);
489    static if (__USE_FILE_OFFSET64)
490    {
491        int getrlimit64(int, rlimit*);
492        int setrlimit64(int, const scope rlimit*);
493        alias getrlimit = getrlimit64;
494        alias setrlimit = setrlimit64;
495    }
496    else
497    {
498        int getrlimit(int, rlimit*);
499        int setrlimit(int, const scope rlimit*);
500    }
501    int getrusage(int, rusage*);
502}
503else version (FreeBSD)
504{
505    int getpriority(int, int);
506    int getrlimit(int, rlimit*);
507    int getrusage(int, rusage*);
508    int setpriority(int, int, int);
509    int setrlimit(int, const scope rlimit*);
510}
511else version (NetBSD)
512{
513    int getpriority(int, int);
514    int getrlimit(int, rlimit*);
515    int getrusage(int, rusage*);
516    int setpriority(int, int, int);
517    int setrlimit(int, const scope rlimit*);
518}
519else version (OpenBSD)
520{
521    int getpriority(int, int);
522    int getrlimit(int, rlimit*);
523    int getrusage(int, rusage*);
524    int setpriority(int, int, int);
525    int setrlimit(int, const scope rlimit*);
526}
527else version (DragonFlyBSD)
528{
529    int getpriority(int, int);
530    int getrlimit(int, rlimit*);
531    int getrusage(int, rusage*);
532    int setpriority(int, int, int);
533    int setrlimit(int, const scope rlimit*);
534}
535else version (CRuntime_Bionic)
536{
537    int getpriority(int, int);
538    int getrlimit(int, rlimit*);
539    int getrusage(int, rusage*);
540    int setpriority(int, int, int);
541    int setrlimit(int, const scope rlimit*);
542}
543else version (CRuntime_Musl)
544{
545    int getpriority(int, id_t);
546    int setpriority(int, id_t, int);
547    int getrlimit(int, rlimit*);
548    int setrlimit(int, const scope rlimit*);
549    alias getrlimit getrlimit64;
550    alias setrlimit setrlimit64;
551    int getrusage(int, rusage*);
552}
553else version (Solaris)
554{
555    int getpriority(int, int);
556    int getrlimit(int, rlimit*);
557    int getrusage(int, rusage*);
558    int setpriority(int, int, int);
559    int setrlimit(int, const scope rlimit*);
560}
561else version (Darwin)
562{
563    int getpriority(int, id_t);
564    int getrlimit(int, rlimit*);
565    int getrusage(int, rusage*);
566    int setpriority(int, id_t, int);
567    int setrlimit(int, const scope rlimit*);
568}
569else version (CRuntime_UClibc)
570{
571    int getpriority(int, id_t);
572    int setpriority(int, id_t, int);
573    static if (__USE_FILE_OFFSET64)
574    {
575        int getrlimit64(int, rlimit*);
576        int setrlimit64(int, const scope rlimit*);
577        alias getrlimit = getrlimit64;
578        alias setrlimit = setrlimit64;
579    }
580    else
581    {
582        int getrlimit(int, rlimit*);
583        int setrlimit(int, const scope rlimit*);
584    }
585    int getrusage(int, rusage*);
586}
587else
588    static assert (false, "Unsupported platform");
589