Whamcloud - gitweb
LU-2153 quota: several fixes for reintegration
[fs/lustre-release.git] / libcfs / libcfs / winnt / winnt-curproc.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * This file is part of Lustre, http://www.lustre.org/
32  * Lustre is a trademark of Sun Microsystems, Inc.
33  *
34  * libcfs/libcfs/winnt/winnt-curproc.c
35  *
36  * Impletion of winnt curproc routines.
37  */
38
39 #define DEBUG_SUBSYSTEM S_LNET
40
41 #include <libcfs/libcfs.h>
42
43 /*
44  * Implementation of cfs_curproc API (see portals/include/libcfs/curproc.h)
45  * for Linux kernel.
46  */
47
48 cfs_task_t this_task =
49     { /* umask */ 0,/* blocked*/0, /* pid */ 0, /* pgrp */ 0,
50       /* uid,euid,suid,fsuid */  0, 0, 0, 0, 
51       /* gid_t gid,egid,sgid,fsgid */ 0, 0, 0, 0,
52       /* ngroups*/ 1, /*cgroups*/ 0, /*groups*/ 0,
53       /* group_info */ NULL,
54       /* cap_effective, cap_inheritable, cap_permitted */  0, 0, 0,
55       /* comm */"sysetm\0",
56       /* journal_info */ NULL
57     };
58
59
60 uid_t  cfs_curproc_uid(void)
61 {
62     return this_task.uid;
63 }
64
65 gid_t  cfs_curproc_gid(void)
66 {
67     return this_task.gid;
68 }
69
70 uid_t  cfs_curproc_fsuid(void)
71 {
72     return this_task.fsuid;
73 }
74
75 gid_t cfs_curproc_fsgid(void)
76 {
77     return this_task.fsgid;
78 }
79
80 pid_t cfs_curproc_pid(void)
81 {
82     return cfs_current()->pid;
83 }
84
85 int cfs_curproc_groups_nr(void)
86 {
87     return this_task.ngroups;
88 }
89
90 void cfs_curproc_groups_dump(gid_t *array, int size)
91 {
92     LASSERT(size <= NGROUPS);
93     size = min_t(int, size, this_task.ngroups);
94     memcpy(array, this_task.groups, size * sizeof(__u32));
95 }
96
97 int cfs_curproc_is_in_groups(gid_t gid)
98 {
99     return in_group_p(gid);
100 }
101
102 mode_t cfs_curproc_umask(void)
103 {
104     return this_task.umask;
105 }
106
107 char  *cfs_curproc_comm(void)
108 {
109     return this_task.comm;
110 }
111
112 void cfs_cap_raise(cfs_cap_t cap)
113 {
114         this_task.cap_effective |= (1 << cap);
115 }
116
117 void cfs_cap_lower(cfs_cap_t cap)
118 {
119         this_task.cap_effective &= ~(1 << cap);
120 }
121
122 int cfs_cap_raised(cfs_cap_t cap)
123 {
124         return this_task.cap_effective & (1 << cap);
125 }
126
127 cfs_cap_t cfs_curproc_cap_pack(void) {
128         return this_task.cap_effective;
129 }
130
131 void cfs_curproc_cap_unpack(cfs_cap_t cap) {
132         this_task.cap_effective = cap;
133 }
134
135 int cfs_capable(cfs_cap_t cap)
136 {
137         return TRUE;
138 }
139
140 /*
141  * Implementation of linux task management routines
142  */
143
144
145 /* global of the task manager structure */
146
147 TASK_MAN cfs_win_task_manger;
148
149 /* global idr context */
150 struct idr_context * cfs_win_task_slot_idp = NULL;
151
152 /*
153  *  task slot routiens
154  */
155
156 PTASK_SLOT
157 alloc_task_slot()
158 {
159     PTASK_SLOT task = NULL;
160
161     if (cfs_win_task_manger.slab) {
162         task = cfs_mem_cache_alloc(cfs_win_task_manger.slab, 0);
163     } else {
164         task = cfs_alloc(sizeof(TASK_SLOT), 0);
165     }
166
167     return task;
168 }
169
170 void
171 init_task_slot(PTASK_SLOT task)
172 {
173     memset(task, 0, sizeof(TASK_SLOT));
174     task->Magic = TASKSLT_MAGIC;
175     task->task  = this_task;
176     cfs_init_event(&task->Event, TRUE, FALSE);
177 }
178
179 void
180 cleanup_task_slot(PTASK_SLOT task)
181 {
182     if (task->task.pid) {
183         cfs_idr_remove(cfs_win_task_slot_idp, task->task.pid);
184     }
185
186     if (cfs_win_task_manger.slab) {
187         cfs_mem_cache_free(cfs_win_task_manger.slab, task);
188     } else {
189         cfs_free(task);
190     }
191 }
192
193 /*
194  *  task manager related routines
195  */
196
197 VOID
198 task_manager_notify(
199     IN HANDLE   ProcessId,
200     IN HANDLE   ThreadId,
201     IN BOOLEAN  Create
202     )
203 {
204     PLIST_ENTRY ListEntry = NULL; 
205     PTASK_SLOT  TaskSlot  = NULL;
206
207     cfs_spin_lock(&(cfs_win_task_manger.Lock));
208
209     ListEntry = cfs_win_task_manger.TaskList.Flink;
210     while (ListEntry != (&(cfs_win_task_manger.TaskList))) {
211
212         TaskSlot = CONTAINING_RECORD(ListEntry, TASK_SLOT, Link);
213
214         if (TaskSlot->Pid == ProcessId && TaskSlot->Tid == ThreadId) {
215
216             if (!Create) {
217                 /* remove the taskslot */
218                 RemoveEntryList(&(TaskSlot->Link));
219                 cfs_win_task_manger.NumOfTasks--;
220
221                 /* now free the task slot */
222                 cleanup_task_slot(TaskSlot);
223             }
224         }
225
226         ListEntry = ListEntry->Flink;
227     }
228
229     cfs_spin_unlock(&(cfs_win_task_manger.Lock));
230 }
231
232 int
233 init_task_manager()
234 {
235     NTSTATUS    status;
236
237     /* initialize the content and magic */
238     memset(&cfs_win_task_manger, 0, sizeof(TASK_MAN));
239     cfs_win_task_manger.Magic = TASKMAN_MAGIC;
240
241     /* initialize the spinlock protection */
242     cfs_spin_lock_init(&cfs_win_task_manger.Lock);
243
244     /* create slab memory cache */
245     cfs_win_task_manger.slab = cfs_mem_cache_create(
246         "TSLT", sizeof(TASK_SLOT), 0, 0);
247
248     /* intialize the list header */
249     InitializeListHead(&(cfs_win_task_manger.TaskList));
250
251     cfs_win_task_slot_idp = cfs_idr_init();
252     if (!cfs_win_task_slot_idp) {
253         return -ENOMEM;
254     }
255
256     /* set the thread creation/destruction notify routine */
257     status = PsSetCreateThreadNotifyRoutine(task_manager_notify);
258
259     if (!NT_SUCCESS(status)) {
260         cfs_enter_debugger();
261         /* remove idr context */
262         if (cfs_win_task_slot_idp) {
263             cfs_idr_exit(cfs_win_task_slot_idp);
264             cfs_win_task_slot_idp = NULL;
265         }
266         return cfs_error_code(status);
267     }
268
269     return 0;
270 }
271
272 void
273 cleanup_task_manager()
274 {
275     PLIST_ENTRY ListEntry = NULL; 
276     PTASK_SLOT  TaskSlot  = NULL;
277
278     /* remove ThreadNotifyRoutine: task_manager_notify */
279     PsRemoveCreateThreadNotifyRoutine(task_manager_notify);
280
281     /* remove idr context */
282     if (cfs_win_task_slot_idp) {
283         cfs_idr_exit(cfs_win_task_slot_idp);
284         cfs_win_task_slot_idp = NULL;
285     }
286
287     /* cleanup all the taskslots attached to the list */
288     cfs_spin_lock(&(cfs_win_task_manger.Lock));
289
290     while (!IsListEmpty(&(cfs_win_task_manger.TaskList))) {
291
292         ListEntry = cfs_win_task_manger.TaskList.Flink;
293         TaskSlot = CONTAINING_RECORD(ListEntry, TASK_SLOT, Link);
294
295         RemoveEntryList(ListEntry);
296         cleanup_task_slot(TaskSlot);
297     }
298
299     cfs_spin_unlock(&cfs_win_task_manger.Lock);
300
301     /* destroy the taskslot cache slab */
302     cfs_mem_cache_destroy(cfs_win_task_manger.slab);
303     memset(&cfs_win_task_manger, 0, sizeof(TASK_MAN));
304 }
305
306
307 /*
308  * schedule routines (task slot list)
309  */
310
311
312 cfs_task_t *
313 cfs_current()
314 {
315     HANDLE      Pid = PsGetCurrentProcessId();
316     HANDLE      Tid = PsGetCurrentThreadId();
317     PETHREAD    Tet = PsGetCurrentThread();
318
319     PLIST_ENTRY ListEntry = NULL; 
320     PTASK_SLOT  TaskSlot  = NULL;
321
322     cfs_spin_lock(&(cfs_win_task_manger.Lock));
323
324     ListEntry = cfs_win_task_manger.TaskList.Flink;
325     while (ListEntry != (&(cfs_win_task_manger.TaskList))) {
326
327         TaskSlot = CONTAINING_RECORD(ListEntry, TASK_SLOT, Link);
328         if (TaskSlot->Pid == Pid && TaskSlot->Tid == Tid) {
329             if (TaskSlot->Tet != Tet) {
330
331                 //
332                 // The old thread was already exit. This must be a
333                 // new thread which get the same Tid to the previous.
334                 //
335
336                 TaskSlot->Tet = Tet;
337             }
338             break;
339
340         } else {
341
342             if (TaskSlot->Pid > Pid) {
343                 TaskSlot = NULL;
344                 break;
345             } else if (TaskSlot->Pid == Pid) {
346                 if (TaskSlot->Tid > Tid) {
347                     TaskSlot = NULL;
348                     break;
349                 }
350             }
351             TaskSlot =  NULL;
352         }
353
354         ListEntry = ListEntry->Flink;
355     }
356
357     if (!TaskSlot) {
358
359         /* allocate new task slot */
360         TaskSlot = alloc_task_slot();
361         if (!TaskSlot) {
362             cfs_enter_debugger();
363             goto errorout;
364         }
365
366         /* set task slot IDs */
367         init_task_slot(TaskSlot);
368         TaskSlot->Pid = Pid;
369         TaskSlot->Tid = Tid;
370         TaskSlot->Tet = Tet;
371         TaskSlot->task.pid = (pid_t)cfs_idr_get_new(cfs_win_task_slot_idp, Tet);
372
373         if (ListEntry == (&(cfs_win_task_manger.TaskList))) {
374             //
375             // Empty case or the biggest case, put it to the tail.
376             //
377             InsertTailList(&(cfs_win_task_manger.TaskList), &(TaskSlot->Link));
378         } else {
379             //
380             // Get a slot and smaller than it's tid, put it just before.
381             //
382             InsertHeadList(ListEntry->Blink, &(TaskSlot->Link));
383         }
384
385         cfs_win_task_manger.NumOfTasks++;
386     }
387
388     //
389     // To Check whether he task structures are arranged in the expected order ?
390     //
391
392     {
393         PTASK_SLOT  Prev = NULL, Curr = NULL;
394         
395         ListEntry = cfs_win_task_manger.TaskList.Flink;
396
397         while (ListEntry != (&(cfs_win_task_manger.TaskList))) {
398
399             Curr = CONTAINING_RECORD(ListEntry, TASK_SLOT, Link);
400             ListEntry = ListEntry->Flink;
401
402             if (Prev) {
403                 if (Prev->Pid > Curr->Pid) {
404                     cfs_enter_debugger();
405                 } else if (Prev->Pid == Curr->Pid) {
406                     if (Prev->Tid > Curr->Tid) {
407                         cfs_enter_debugger();
408                     }
409                 }
410             }
411
412             Prev = Curr;
413         }
414     }
415
416 errorout:
417
418     cfs_spin_unlock(&(cfs_win_task_manger.Lock));
419
420     if (!TaskSlot) {
421         cfs_enter_debugger();
422         return NULL;
423     }
424
425     return (&(TaskSlot->task));
426 }
427
428 /* deschedule for a bit... */
429 void
430 cfs_pause(cfs_duration_t ticks)
431 {
432     cfs_schedule_timeout_and_set_state(CFS_TASK_UNINTERRUPTIBLE, ticks);
433 }
434
435 void
436 cfs_schedule_timeout_and_set_state(cfs_task_state_t state, int64_t time)
437 {
438     cfs_task_t * task = cfs_current();
439     PTASK_SLOT   slot = NULL;
440
441     if (!task) {
442         cfs_enter_debugger();
443         return;
444     }
445
446     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
447     cfs_assert(slot->Magic == TASKSLT_MAGIC);
448
449     if (time == CFS_MAX_SCHEDULE_TIMEOUT) {
450         time = 0;
451     }
452
453     cfs_wait_event_internal(&(slot->Event), time);
454 }
455
456 void
457 cfs_schedule()
458 {
459     cfs_schedule_timeout_and_set_state(CFS_TASK_UNINTERRUPTIBLE, 0);
460 }
461
462 int
463 wake_up_process(
464     cfs_task_t * task
465     )
466 {
467     PTASK_SLOT   slot = NULL;
468
469     if (!task) {
470         cfs_enter_debugger();
471         return 0;
472     }
473
474     slot = CONTAINING_RECORD(task, TASK_SLOT, task);
475     cfs_assert(slot->Magic == TASKSLT_MAGIC);
476
477     cfs_wake_event(&(slot->Event));
478
479     return TRUE;
480 }
481
482 void
483 sleep_on(cfs_waitq_t *waitq)
484 {
485         cfs_waitlink_t link;
486         
487         cfs_waitlink_init(&link);
488         cfs_waitq_add(waitq, &link);
489         cfs_waitq_wait(&link, CFS_TASK_INTERRUPTIBLE);
490         cfs_waitq_del(waitq, &link);
491 }
492
493 EXPORT_SYMBOL(cfs_curproc_uid);
494 EXPORT_SYMBOL(cfs_curproc_pid);
495 EXPORT_SYMBOL(cfs_curproc_gid);
496 EXPORT_SYMBOL(cfs_curproc_fsuid);
497 EXPORT_SYMBOL(cfs_curproc_fsgid);
498 EXPORT_SYMBOL(cfs_curproc_umask);
499 EXPORT_SYMBOL(cfs_curproc_comm);
500 EXPORT_SYMBOL(cfs_curproc_groups_nr);
501 EXPORT_SYMBOL(cfs_curproc_groups_dump);
502 EXPORT_SYMBOL(cfs_curproc_is_in_groups);
503 EXPORT_SYMBOL(cfs_cap_raise);
504 EXPORT_SYMBOL(cfs_cap_lower);
505 EXPORT_SYMBOL(cfs_cap_raised);
506 EXPORT_SYMBOL(cfs_curproc_cap_pack);
507 EXPORT_SYMBOL(cfs_curproc_cap_unpack);
508 EXPORT_SYMBOL(cfs_capable);