Whamcloud - gitweb
b=20101 lfs getstripe -d test for sanity 27w
[fs/lustre-release.git] / lustre / liblustre / lutil.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #include <stdlib.h>
38 #include <string.h>
39 #include <assert.h>
40 #include <signal.h>
41 #include <sys/types.h>
42
43 #include <fcntl.h>
44 #ifdef HAVE_NETDB_H
45 #include <netdb.h>
46 #endif
47 #ifdef _AIX
48 #include "syscall_AIX.h"
49 #else
50 #include <sys/syscall.h>
51 #endif
52 #include <sys/utsname.h>
53 #ifdef HAVE_NETINET_IN_H
54 #include <netinet/in.h>
55 #endif
56 #include <sys/socket.h>
57 #ifdef HAVE_ARPA_INET_H
58 #include <arpa/inet.h>
59 #endif
60 #ifdef HAVE_CATAMOUNT_DATA_H
61 #include <catamount/data.h>
62 #endif
63
64 #include "lutil.h"
65
66
67 unsigned int libcfs_subsystem_debug = ~0 - (S_LNET | S_LND);
68 unsigned int libcfs_debug = 0;
69
70 struct task_struct     *current;
71
72 void *inter_module_get(char *arg)
73 {
74         if (!strcmp(arg, "ldlm_cli_cancel_unused"))
75                 return ldlm_cli_cancel_unused;
76         else if (!strcmp(arg, "ldlm_namespace_cleanup"))
77                 return ldlm_namespace_cleanup;
78         else if (!strcmp(arg, "ldlm_replay_locks"))
79                 return ldlm_replay_locks;
80         else if (!strcmp(arg, "mdc_quota_interface"))
81                 return &mdc_quota_interface;
82         else if (!strcmp(arg, "lmv_quota_interface"))
83                 return &lmv_quota_interface;
84         else if (!strcmp(arg, "osc_quota_interface"))
85                 return &osc_quota_interface;
86         else if (!strcmp(arg, "lov_quota_interface"))
87                 return &lov_quota_interface;
88         else
89                 return NULL;
90 }
91
92 /*
93  * random number generator stuff
94  */
95
96 #ifdef HAVE_GETHOSTBYNAME
97 static int get_ipv4_addr()
98 {
99         struct utsname myname;
100         struct hostent *hptr;
101         int ip;
102
103         if (uname(&myname) < 0)
104                 return 0;
105
106         hptr = gethostbyname(myname.nodename);
107         if (hptr == NULL ||
108             hptr->h_addrtype != AF_INET ||
109             *hptr->h_addr_list == NULL) {
110                 CWARN("Warning: fail to get local IPv4 address\n");
111                 return 0;
112         }
113
114         ip = ntohl(*((int *) *hptr->h_addr_list));
115
116         return ip;
117 }
118 #endif
119
120 void liblustre_init_random()
121 {
122         int seed[2];
123         struct timeval tv;
124
125 #ifdef LIBLUSTRE_USE_URANDOM
126         int _rand_dev_fd;
127         _rand_dev_fd = syscall(SYS_open, "/dev/urandom", O_RDONLY);
128         if (_rand_dev_fd >= 0) {
129                 if (syscall(SYS_read, _rand_dev_fd,
130                             &seed, sizeof(seed)) == sizeof(seed)) {
131                         ll_srand(seed[0], seed[1]);
132                         syscall(SYS_close, _rand_dev_fd);
133                         return;
134                 }
135                 syscall(SYS_close, _rand_dev_fd);
136         }
137 #endif /* LIBLUSTRE_USE_URANDOM */
138
139 #ifdef HAVE_GETHOSTBYNAME
140         seed[0] = get_ipv4_addr();
141 #else
142         seed[0] = _my_pnid;
143 #endif
144         gettimeofday(&tv, NULL);
145         ll_srand(tv.tv_sec ^ __swab32(seed[0]), tv.tv_usec ^__swab32(getpid()));
146 }
147
148 static void init_capability(__u32 *res)
149 {
150 #ifdef HAVE_LIBCAP
151         cap_t syscap;
152         cap_flag_value_t capval;
153         int i;
154
155         *res = 0;
156
157         syscap = cap_get_proc();
158         if (!syscap) {
159                 CWARN("Warning: failed to get system capability, "
160                       "set to minimal\n");
161                 return;
162         }
163
164         for (i = 0; i < sizeof(cap_value_t) * 8; i++) {
165                 if (!cap_get_flag(syscap, i, CAP_EFFECTIVE, &capval)) {
166                         if (capval == CAP_SET) {
167                                 *res |= 1 << i;
168                         }
169                 }
170         }
171 #else
172         /*
173          * set fake cap flags to ship to linux server
174          * from client platforms that have none (eg. catamount)
175          *  full capability for root
176          *  no capability for anybody else
177          */
178 #define FAKE_ROOT_CAP 0x1ffffeff
179 #define FAKE_USER_CAP 0
180
181         *res = (current->fsuid == 0) ? FAKE_ROOT_CAP: FAKE_USER_CAP;
182 #endif
183 }
184
185 int cfs_curproc_is_in_groups(gid_t gid)
186 {
187         int i;
188
189         if (gid == current->fsgid)
190                 return 1;
191
192         for (i = 0; i < current->ngroups; i++) {
193                 if (gid == current->groups[i])
194                         return 1;
195         }
196
197         return 0;
198 }
199
200 int liblustre_init_current(char *comm)
201 {
202         current = malloc(sizeof(*current));
203         if (!current) {
204                 CERROR("Not enough memory\n");
205                 return -ENOMEM;
206         }
207
208         strncpy(current->comm, comm, sizeof(current->comm));
209         current->pid = getpid();
210         current->gid = getgid();
211         current->fsuid = geteuid();
212         current->fsgid = getegid();
213         memset(&current->pending, 0, sizeof(current->pending));
214
215         current->max_groups = sysconf(_SC_NGROUPS_MAX);
216         current->groups = malloc(sizeof(gid_t) * current->max_groups);
217         if (!current->groups) {
218                 CERROR("Not enough memory\n");
219                 return -ENOMEM;
220         }
221         current->ngroups = getgroups(current->max_groups, current->groups);
222         if (current->ngroups < 0) {
223                 perror("Error getgroups");
224                 return -EINVAL;
225         }
226
227         init_capability(&current->cap_effective);
228
229         return 0;
230 }
231
232 void cfs_cap_raise(cfs_cap_t cap)
233 {
234         current->cap_effective |= (1 << cap);
235 }
236
237 void cfs_cap_lower(cfs_cap_t cap)
238 {
239         current->cap_effective &= ~(1 << cap);
240 }
241
242 int cfs_cap_raised(cfs_cap_t cap)
243 {
244         return current->cap_effective & (1 << cap);
245 }
246
247 cfs_cap_t cfs_curproc_cap_pack(void) {
248         return cfs_current()->cap_effective;
249 }
250
251 void cfs_curproc_cap_unpack(cfs_cap_t cap) {
252         cfs_current()->cap_effective = cap;
253 }
254
255 int cfs_capable(cfs_cap_t cap)
256 {
257         return cfs_cap_raised(cap);
258 }
259
260 int init_lib_portals()
261 {
262         int rc;
263         ENTRY;
264
265         rc = libcfs_debug_init(5 * 1024 * 1024);
266         if (rc != 0) {
267                 CERROR("libcfs_debug_init() failed: %d\n", rc);
268                 RETURN (-ENXIO);
269         }
270
271         rc = LNetInit();
272         if (rc != 0) {
273                 CERROR("LNetInit() failed: %d\n", rc);
274                 RETURN (-ENXIO);
275         }
276         RETURN(0);
277 }
278
279 extern void ptlrpc_exit_portals(void);
280 void cleanup_lib_portals()
281 {
282         libcfs_debug_cleanup();
283         ptlrpc_exit_portals();
284 }