4d584fb2c430a8578049beafd77d1de708e52c65
[projects/modsched/linux.git] / kernel / sched.new / core.c
1 /*
2  *  kernel/sched/core.c
3  *
4  *  Kernel scheduler and related syscalls
5  *
6  *  Copyright (C) 1991-2002  Linus Torvalds
7  *
8  *
9  */
10
11 #include <linux/init.h>
12 #include <linux/completion.h>
13 #include <linux/kernel_stat.h>
14 #include <linux/syscalls.h>
15
16 #include <linux/cgroup.h>
17 #include "sched.h"
18
19
20
21
22
23 //
24 // Variables
25 //
26
27 /*
28  * kernel/sched/rt.c:10
29  * default timeslice is 100 msecs (used only for SCHED_RR tasks).
30  * Timeslices get refilled after they expire. RR_TIMESLICE is defined as
31  * (100 * HZ / 1000) and is assigned to sched_rr_timeslice.
32  */
33 int sched_rr_timeslice = RR_TIMESLICE;
34
35 /*
36  * kernel/sched/fair.c:80
37  * After fork, child runs first. If set to 0 (default) then
38  * parent will (try to) run first.
39  */
40 unsigned int sysctl_sched_child_runs_first = 0;
41
42 /*
43  * kernel/sched/core.c:289
44  * Period over which we measure -rt task cpu usage in us.
45  * default: 1s (1000000)
46  */
47 unsigned int sysctl_sched_rt_period = 1000000;
48
49 /*
50  * /kernel/sched/core.c:2081
51  * Variables and functions for calc_load
52  */
53 unsigned long avenrun[3];
54
55 /*
56  * kernel/sched/core.c:297
57  * part of the period that we allow rt tasks to run in us.
58  * default: 0.95s (950000)
59  */
60 int sysctl_sched_rt_runtime = 950000;
61
62 /*
63  * /kernel/sched/core.c:6866
64  *
65  */
66 struct task_group root_task_group;
67
68 /*
69  * /kernel/sched/core.c:2623
70  * unknown
71  */
72 DEFINE_PER_CPU(struct kernel_stat, kstat);
73 DEFINE_PER_CPU(struct kernel_cpustat, kernel_cpustat);
74
75
76
77
78
79 //
80 // Functions
81 //
82
83 /*
84  * /kernel/sched/cputime.c:436
85  * Account multiple ticks of idle time.
86  * @ticks: number of stolen ticks
87  */
88 void account_idle_ticks(unsigned long ticks)
89 {
90         return;
91 }
92
93 /*
94  * /kernel/sched/cputime.c:397
95  * Account a single tick of cpu time.
96  * @p: the process that the cpu time gets accounted to
97  * @user_tick: indicates if the tick is a user or a system tick
98  */
99 void account_process_tick(struct task_struct *p, int user_tick)
100 {
101         return;
102 }
103
104 /*
105  * /kernel/sched/core.c:2092
106  * get_avenrun - get the load average array
107  * @loads:    pointer to dest load array
108  * @offset:    offset to add
109  * @shift:    shift count to shift the result left
110  *
111  * These values are estimates at best, so no need for locking.
112  */
113 void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
114 {
115         return;
116 }
117
118 /*
119  * /kernel/sched/core.c:2363
120  * calc_load - update the avenrun load estimates 10 ticks after the
121  * CPUs have updated calc_load_tasks.
122  */
123 void calc_global_load(unsigned long ticks)
124 {
125         return;
126 }
127
128 /*
129  * /kernel/sched/core.c:2197
130  * We're going into NOHZ mode, if there's any pending delta, fold it
131  * into the pending idle delta.
132  */
133 /*void calc_load_enter_idle(void)
134 {
135         return;
136 }*/
137
138 /*
139  * /kernel/sched/core.c:2213
140  * If we're still before the sample window, we're done.
141  *
142  * We woke inside or after the sample window, this means we're already
143  * accounted through the nohz accounting, so skip the entire deal and
144  * sync up for the next window.
145  */
146 /*void calc_load_exit_idle(void)
147 {
148         return;
149 }*/
150
151 /*
152  * /kernel/sched/core.c:3668
153  * Check if a task can reduce its nice value
154  * @p: task
155  * @nice: nice value
156  */
157 int can_nice(const struct task_struct *p, const int nice)
158 {
159         return 0;
160 }
161
162 /**
163  * kernel/sched/core.c:3768
164  * idle_task - return the idle task for a given cpu.
165  * @cpu: the processor in question.
166  */
167 struct task_struct *idle_task(int cpu)
168 {
169         return 0;
170 }
171
172 /**
173  * /kernel/sched/core.c:3742
174  * idle_cpu - is a given cpu idle currently?
175  * @cpu: the processor in question.
176  */
177 int idle_cpu(int cpu)
178 {
179         return 0;
180 }
181
182 /**
183  * /kernel/sched/core.c:4674
184  * init_idle - set up an idle thread for a given CPU
185  * @idle: task in question
186  * @cpu: cpu the idle task belongs to
187  *
188  * NOTE: this function does not set the idle thread's NEED_RESCHED
189  * flag, to make booting more robust.
190  */
191 void __cpuinit init_idle(struct task_struct *idle, int cpu)
192 {
193         return;
194 }
195
196 /*
197  * /kernel/sched/core.c:4669
198  * Sets sched_class of idle task, see struct sched_class idle_sched_class;
199  */
200 void __cpuinit init_idle_bootup_task(struct task_struct *idle)
201 {
202         return;
203 }
204
205 /*
206  * /kernel/sched/core.c:7108
207  * Calls private function
208  * static void normalize_task(struct rq *rq, struct task_struct *p)
209  */
210 void normalize_rt_tasks(void)
211 {
212         return;
213 }
214
215 /*
216  * /kernel/sched/core.c:1997
217  * nr_running and nr_context_switches:
218  *
219  * externally visible scheduler statistics:
220  *   current number of runnable threads
221  *   total number of context switches performed since bootup.
222  */
223 unsigned long nr_running(void)
224 {
225         return 0;
226 }
227
228 unsigned long long nr_context_switches(void)
229 {
230         return 0;
231 }
232
233 /*
234  * /kernel/sched/core.c:2017
235  * number of threads waiting on IO
236  */
237 unsigned long nr_iowait(void)
238 {
239         return 0;
240 }
241
242 /*
243  * rt_mutex_setprio - set the current priority of a task
244  * @p: task
245  * @prio: prio value (kernel-internal form)
246  *
247  * This function changes the 'effective' priority of a task. It does
248  * not touch ->normal_prio like __setscheduler().
249  *
250  * Used by the rt_mutex code to implement priority inheritance logic.
251  */
252 void rt_mutex_setprio(struct task_struct *p, int prio)
253 {
254         return;
255 }
256
257 /**
258  * sched_clock_cpu - returns current time in nanosec units
259  * using scheduler clock function.
260  * @param: cpu id
261  */
262 u64 sched_clock_cpu(int cpu)
263 {
264         return 0;
265 }
266
267 /*
268  * kernel/sched/clock.c:350
269  * Initialize/Start scheduler clock.
270  */
271 void sched_clock_init(void)
272 {
273         return;
274 }
275
276 /*
277  * kernel/sched/core.c:1622
278  * fork()/clone()-time setup:
279  */
280 void sched_fork(struct task_struct *p)
281 {
282         return;
283 }
284
285 /**
286  * kernel/sched/core.c:4213
287  * This functions stores the CPU affinity mask for the process or thread with the ID pid in the cpusetsize
288  * bytes long bitmap pointed to by cpuset. If successful, the function always initializes all bits in the
289  * cpu_set_t object and returns zero.
290  *
291  * If pid does not correspond to a process or thread on the system the or the function fails for some other
292  * reason, it returns -1 and errno is set to represent the error condition.
293  */
294 long sched_getaffinity(pid_t pid, struct cpumask *mask)
295 {
296         return 0;
297 }
298
299 /**
300  * kernel/sched/core.c:6872
301  * Initialize the scheduler
302  */
303 void sched_init(void)
304 {
305         printk("sched init\n");
306         return;
307 }
308
309 /**
310  * kernel/sched/core.c:6850
311  */
312 void sched_init_smp(void)
313 {
314         return;
315 }
316
317 /**
318  * kernel/sched/core.c:7571
319  */
320 int sched_rr_handler(struct ctl_table *table, int write,
321                 void __user *buffer, size_t *lenp,
322                 loff_t *ppos)
323 {
324         return 0;
325 }
326
327 /**
328  * kernel/sched/core.c:4111
329  * This function installs the cpusetsize bytes long affinity mask pointed to by cpuset for the process or
330  * thread with the ID pid. If successful the function returns zero and the scheduler will in future take the
331  * affinity information into account.
332  */
333 long sched_setaffinity(pid_t pid, const struct cpumask *new_mask)
334 {
335         return 0;
336 }
337
338 /**
339  * kernel/sched/core.c:3975
340  * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
341  * @p: the task in question.
342  * @policy: new policy.
343  * @param: structure containing the new RT priority.
344  *
345  * NOTE that the task may be already dead.
346  */
347 int sched_setscheduler(struct task_struct *p, int policy,
348                 const struct sched_param *param)
349 {
350         return 0;
351 }
352
353 /**
354  * kernel/sched/core.c:3993
355  * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
356  * @p: the task in question.
357  * @policy: new policy.
358  * @param: structure containing the new RT priority.
359  *
360  * Just like sched_setscheduler, only don't bother checking if the
361  * current context has permission.  For example, this is needed in
362  * stop_machine(): we create temporary high priority worker threads,
363  * but our caller might not have that capability.
364  */
365 int sched_setscheduler_nocheck(struct task_struct *p, int policy,
366 const struct sched_param *param)
367 {
368         return 0;
369 }
370
371 /**
372  * kernel/sched/core.c:4601
373  */
374 void sched_show_task(struct task_struct *p)
375 {
376         return;
377 }
378
379 /**
380  * kernel/sched/core.c:1905
381  * schedule_tail - first thing a freshly forked thread must call.
382  * @prev: the thread we just switched away from.
383  */
384 void schedule_tail(struct task_struct *prev)
385 {
386         return;
387 }
388
389 /*
390  * kernel/sched/core.c:2684
391  * This function gets called by the timer code, with HZ frequency.
392  * We call it with interrupts disabled.
393  */
394 void scheduler_tick(void)
395 {
396         return;
397 }
398
399 /*
400  * kernel/sched/core.c:2649
401  * Lock/unlock the current runqueue - to extract task statistics:
402  */
403 unsigned long long task_delta_exec(struct task_struct *p)
404 {
405         return 0;
406 }
407
408 /**
409  * kernel/sched/core.c:3727
410  * task_prio - return the priority value of a given task.
411  * @p: the task in question.
412  *
413  * This is the priority value as seen by users in /proc.
414  * RT tasks are offset by -200. Normal tasks are centered
415  * around 0, value goes from -16 to +15.
416  */
417 int task_prio(const struct task_struct *p)
418 {
419         return 0;
420 }
421
422 /*
423  * kernel/sched/core.c:2667
424  * Return accounted runtime for the task.
425  * In case the task is currently running, return the runtime plus current's
426  * pending runtime that have not been accounted yet.
427  */
428 unsigned long long task_sched_runtime(struct task_struct *task)
429 {
430         return 0;
431 }
432
433 /*
434  * kernel/sched/core.c:2024
435  * this_cpu_load - returns load of the cpu
436  */
437 unsigned long this_cpu_load(void)
438 {
439         return 0;
440 }
441
442 /*
443  * kernel/sched/core.c:2556
444  * update_cpu_load_nohz - called from tick_nohz_idle_exit() -- try and fix up the ticks we missed.
445  */
446 void update_cpu_load_nohz(void)
447 {
448         return;
449 }
450
451 /*
452  * kernel/sched/core.c:1703
453  * wake_up_new_task - wake up a newly created task for the first time.
454  *
455  * This function will do some initial scheduler statistics housekeeping
456  * that must be done for every newly created context, then puts the task
457  * on the runqueue and wakes it.
458  */
459 void wake_up_new_task(struct task_struct *tsk)
460 {
461         return;
462 }
463
464 /*
465  * kernel/sched/core.c:4315
466  */
467 int __sched _cond_resched(void)
468 {
469         return 0;
470 }
471
472 /*
473  * kernel/sched/core.c:2966
474  */
475 asmlinkage void __sched schedule(void)
476 {
477         return;
478 }
479
480 /**
481  * kernel/sched/core.c:3149
482  * __wake_up - wake up threads blocked on a waitqueue.
483  * @q: the waitqueue
484  * @mode: which threads
485  * @nr_exclusive: how many wake-one or wake-many threads to wake up
486  * @key: is directly passed to the wakeup function
487  *
488  * It may be assumed that this function implies a write memory barrier before
489  * changing the task state if and only if any tasks are woken up.
490  */
491 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key)
492 {
493         return;
494 }
495
496 /**
497  * kernel/sched/core.c:1536
498  * wake_up_process - Wake up a specific process
499  * @p: The process to be woken up.
500  *
501  * Attempt to wake up the nominated process and move it to the set of runnable
502  * processes.  Returns 1 if the process was woken up, 0 if it was already
503  * running.
504  *
505  * It may be assumed that this function implies a write memory barrier before
506  * changing the task state if and only if any tasks are woken up.
507  */
508 int wake_up_process(struct task_struct *p)
509 {
510         return 0;
511 }
512
513 /**
514  * kernel/sched/core.c:3322
515  * wait_for_completion: - waits for completion of a task
516  * @x:  holds the state of this particular completion
517  *
518  * This waits to be signaled for completion of a specific task. It is NOT
519  * interruptible and there is no timeout.
520  *
521  * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
522  * and interrupt capability. Also see complete().
523  */
524 void __sched wait_for_completion(struct completion *x)
525 {
526         return;
527 }
528
529 /**
530  * kernel/sched/core.c:3231
531  * complete: - signals a single thread waiting on this completion
532  * @x:  holds the state of this particular completion
533  *
534  * This will wake up a single thread waiting on this completion. Threads will be
535  * awakened in the same order in which they were queued.
536  *
537  * See also complete_all(), wait_for_completion() and related routines.
538  *
539  * It may be assumed that this function implies a write memory barrier before
540  * changing the task state if and only if any tasks are woken up.
541  */
542 void complete(struct completion *x)
543 {
544         return;
545 }
546
547 /**
548  * kernel/sched/core.c:2995
549  * schedule_preempt_disabled - called with preemption disabled
550  *
551  * Returns with preemption disabled. Note: preempt_count must be 1
552  */
553 void __sched schedule_preempt_disabled(void)
554 {
555         return;
556 }
557
558 /*
559  * kernel/sched/core.c:6858
560  */
561 int in_sched_functions(unsigned long addr)
562 {
563         return 0;
564 }
565
566 /*
567  * kernel/sched/core.c:4333
568  * __cond_resched_lock() - if a reschedule is pending, drop the given lock,
569  * call schedule, and on return reacquire the lock.
570  *
571  * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
572  * operations here to prevent schedule() from being called twice (once via
573  * spin_unlock(), once by hand).
574  */
575 int __cond_resched_lock(spinlock_t *lock)
576 {
577         return 0;
578 }
579
580 /*
581  * kernel/sched/core.c:4333
582  */
583 int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags, void *key)
584 {
585         return 0;
586 }
587
588 /**
589  * kernel/sched/core.c:3426
590  * wait_for_completion_killable: - waits for completion of a task (killable)
591  * @x:  holds the state of this particular completion
592  *
593  * This waits to be signaled for completion of a specific task. It can be
594  * interrupted by a kill signal.
595  *
596  * The return value is -ERESTARTSYS if interrupted, 0 if completed.
597  */
598 int __sched wait_for_completion_killable(struct completion *x)
599 {
600         return 0;
601 }
602
603 /**
604  * kernel/sched/core.c:3192
605  * __wake_up_sync_key - wake up threads blocked on a waitqueue.
606  * @q: the waitqueue
607  * @mode: which threads
608  * @nr_exclusive: how many wake-one or wake-many threads to wake up
609  * @key: opaque value to be passed to wakeup targets
610  *
611  * The sync wakeup differs that the waker knows that it will schedule
612  * away soon, so while the target thread will be woken up, it will not
613  * be migrated to another CPU - ie. the two threads are 'synchronized'
614  * with each other. This can prevent needless bouncing between CPUs.
615  *
616  * On UP it can prevent extra preemption.
617  *
618  * It may be assumed that this function implies a write memory barrier before
619  * changing the task state if and only if any tasks are woken up.
620  */
621 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
622                         int nr_exclusive, void *key)
623 {
624         return;
625 }
626
627 /*
628  * kernel/sched/core.c:1543
629  */
630 int wake_up_state(struct task_struct *p, unsigned int state)
631 {
632         return 0;
633 }
634
635 /**
636  * kernel/sched/core.c:4389
637  * yield - yield the current processor to other threads.
638  *
639  * Do not ever use this function, there's a 99% chance you're doing it wrong.
640  *
641  * The scheduler is at all times free to pick the calling task as the most
642  * eligible task to run, if removing the yield() call from your code breaks
643  * it, its already broken.
644  *
645  * Typical broken usage is:
646  *
647  * while (!event)
648  *      yield();
649  *
650  * where one assumes that yield() will let 'the other' process run that will
651  * make event true. If the current task is a SCHED_FIFO task that will never
652  * happen. Never use yield() as a progress guarantee!!
653  *
654  * If you want to use yield() to wait for something, use wait_event().
655  * If you want to use yield() to be 'nice' for others, use cond_resched().
656  * If you still want to use yield(), do not!
657  */
658 void __sched yield(void)
659 {
660         return;
661 }
662
663 /**
664  * kernel/sched/core.c:892
665  * task_curr - is this task currently executing on a CPU?
666  * @p: the task in question.
667  */
668 inline int task_curr(const struct task_struct *p)
669 {
670         return 0;
671 }
672
673 /**
674  * kernel/sched/core.c:3736
675  * task_nice - return the nice value of a given task.
676  * @p: the task in question.
677  */
678 int task_nice(const struct task_struct *p)
679 {
680         return 0;
681 }
682
683 /*
684  * kernel/sched/core.c:3616
685  */
686 void set_user_nice(struct task_struct *p, long nice)
687 {
688         return;
689 }
690
691 /*
692  * kernel/sched/core.c:3169
693  */
694 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
695 {
696         return;
697 }
698
699 /*
700  * kernel/sched/core.c:2018
701  */
702 unsigned long nr_iowait_cpu(int cpu)
703 {
704         return 0;
705 }
706
707 /*
708  * kernel/sched/core.c:4474
709  * This task is about to go to sleep on IO. Increment rq->nr_iowait so
710  * that process accounting knows that this is a task in IO wait state.
711  */
712 void __sched io_schedule(void)
713 {
714         return;
715 }
716
717 /*
718  * kernel/sched/core.c:4489
719  */
720 long __sched io_schedule_timeout(long timeout)
721 {
722         return 0;
723 }
724
725 /*
726  * kernel/sched/core.c:7590
727  */
728 int sched_rt_handler(struct ctl_table *table, int write,
729                 void __user *buffer, size_t *lenp,
730                 loff_t *ppos)
731 {
732         return 0;
733 }
734
735 /*
736  * kernel/sched/core.c:3213
737  * __wake_up_sync - see __wake_up_sync_key()
738  */
739 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
740 {
741         return;
742 }
743
744 /*
745  * kernel/sched/core.c:3163
746  * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
747  */
748 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
749 {
750         return;
751 }
752
753 /**
754  * kernel/sched/core.c:3355
755  * wait_for_completion_io: - waits for completion of a task
756  * @x:  holds the state of this particular completion
757  *
758  * This waits to be signaled for completion of a specific task. It is NOT
759  * interruptible and there is no timeout. The caller is accounted as waiting
760  * for IO.
761  */
762 void __sched wait_for_completion_io(struct completion *x)
763 {
764         return;
765 }
766
767 /*
768  * kernel/sched/core.c:4634
769  */
770 void show_state_filter(unsigned long state_filter)
771 {
772         return;
773 }
774
775 /**
776  * kernel/sched/core.c:3251
777  * complete_all: - signals all threads waiting on this completion
778  * @x:  holds the state of this particular completion
779  *
780  * This will wake up all threads waiting on this particular completion event.
781  *
782  * It may be assumed that this function implies a write memory barrier before
783  * changing the task state if and only if any tasks are woken up.
784  */
785 void complete_all(struct completion *x)
786 {
787         return;
788 }
789
790 /**
791  * kernel/sched/core.c:3341
792  * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
793  * @x:  holds the state of this particular completion
794  * @timeout:  timeout value in jiffies
795  *
796  * This waits for either a completion of a specific task to be signaled or for a
797  * specified timeout to expire. The timeout is in jiffies. It is not
798  * interruptible.
799  *
800  * The return value is 0 if timed out, and positive (at least 1, or number of
801  * jiffies left till timeout) if completed.
802  */
803 unsigned long __sched
804 wait_for_completion_timeout(struct completion *x, unsigned long timeout)
805 {
806         return 0;
807 }
808
809
810
811
812
813 /*
814  * Syscalls
815  *
816  * Help:
817  * SYSCALL_DEFINEx will be replaced by asmlinkage data_type function_name
818  * asmlinkage:  tells the compile that the arguments of the function are
819  *                              not placed in the registers but rather to find on stack
820  */
821
822 /*
823  * kernel/sched/core.c:3686
824  * sys_nice - change the priority of the current process.
825  * @increment: priority increment
826  *
827  * sys_setpriority is a more generic, but much slower function that
828  * does similar things.
829  */
830 SYSCALL_DEFINE1(nice, int, increment)
831 {
832         return 0;
833 }
834
835 /**
836  * kernel/sched/core.c:4248
837  * sys_sched_getaffinity - get the cpu affinity of a process
838  * @pid: pid of the process
839  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
840  * @user_mask_ptr: user-space pointer to hold the current cpu mask
841  */
842 SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
843                 unsigned long __user *, user_mask_ptr)
844 {
845         return 0;
846 }
847
848 /**
849  * kernel/sched/core.c:4197
850  * sys_sched_setaffinity - set the cpu affinity of a process
851  * @pid: pid of the process
852  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
853  * @user_mask_ptr: user-space pointer to the new cpu mask
854  */
855 SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
856                 unsigned long __user *, user_mask_ptr)
857 {
858         return 0;
859 }
860
861 /**
862  * kernel/sched/core.c:4562
863  * sys_sched_rr_get_interval - return the default timeslice of a process.
864  * @pid: pid of the process.
865  * @interval: userspace pointer to the timeslice value.
866  *
867  * this syscall writes the default timeslice value of a given process
868  * into the user-space timespec buffer. A value of '0' means infinity.
869  */
870 SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
871                 struct timespec __user *, interval)
872 {
873         return 0;
874 }
875
876 /**
877  * kernel/sched/core.c:4282
878  * sys_sched_yield - yield the current processor to other threads.
879  *
880  * This function yields the current CPU to other tasks. If there are no
881  * other threads running on this CPU then this function will return.
882  */
883 SYSCALL_DEFINE0(sched_yield)
884 {
885         return 0;
886 }
887
888 /**
889  * kernel/sched/core.c:4027
890  * sys_sched_setscheduler - set/change the scheduler policy and RT priority
891  * @pid: the pid in question.
892  * @policy: new policy.
893  * @param: structure containing the new RT priority.
894  */
895 SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
896                 struct sched_param __user *, param)
897 {
898         return 0;
899 }
900
901 /**
902  * kernel/sched/core.c:4051
903  * sys_sched_getscheduler - get the policy (scheduling class) of a thread
904  * @pid: the pid in question.
905  */
906 SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
907 {
908         return 0;
909 }
910
911 /**
912  * kernel/sched/core.c:4512
913  * sys_sched_get_priority_max - return maximum RT priority.
914  * @policy: scheduling class.
915  *
916  * this syscall returns the maximum rt_priority that can be used
917  * by a given scheduling class.
918  */
919 SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
920 {
921         return 0;
922 }
923
924 /**
925  * kernel/sched/core.c:4537
926  * sys_sched_get_priority_min - return minimum RT priority.
927  * @policy: scheduling class.
928  *
929  * this syscall returns the minimum rt_priority that can be used
930  * by a given scheduling class.
931  */
932 SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
933 {
934         return 0;
935 }
936
937 /**
938  * kernel/sched/core.c:4042
939  * sys_sched_setparam - set/change the RT priority of a thread
940  * @pid: the pid in question.
941  * @param: structure containing the new RT priority.
942  */
943 SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
944 {
945         return 0;
946 }
947
948 /**
949  * kernel/sched/core.c:4077
950  * sys_sched_getparam - get the RT priority of a thread
951  * @pid: the pid in question.
952  * @param: structure containing the RT priority.
953  */
954 SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
955 {
956         return 0;
957 }