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 <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, "osc_quota_interface"))
  81                 return &osc_quota_interface;
  82         else if (!strcmp(arg, "mdc_quota_interface"))
  83                 return &mdc_quota_interface;
  84         else if (!strcmp(arg, "lov_quota_interface"))
  85                 return &lov_quota_interface;
  86         else
  87                 return NULL;
  88 }
  89
  90 /*
  91  * random number generator stuff
  92  */
  93
  94 #ifdef HAVE_GETHOSTBYNAME
  95 static int get_ipv4_addr()
  96 {
  97         struct utsname myname;
  98         struct hostent *hptr;
  99         int ip;
 100
 101         if (uname(&myname) < 0)
 102                 return 0;
 103
 104         hptr = gethostbyname(myname.nodename);
 105         if (hptr == NULL ||
 106             hptr->h_addrtype != AF_INET ||
 107             *hptr->h_addr_list == NULL) {
 108                 CWARN("Warning: fail to get local IPv4 address\n");
 109                 return 0;
 110         }
 111
 112         ip = ntohl(*((int *) *hptr->h_addr_list));
 113
 114         return ip;
 115 }
 116 #endif
 117
 118 void liblustre_init_random()
 119 {
 120         int seed[2];
 121         struct timeval tv;
 122
 123 #ifdef LIBLUSTRE_USE_URANDOM
 124         int _rand_dev_fd;
 125         _rand_dev_fd = syscall(SYS_open, "/dev/urandom", O_RDONLY);
 126         if (_rand_dev_fd >= 0) {
 127                 if (syscall(SYS_read, _rand_dev_fd,
 128                             &seed, sizeof(seed)) == sizeof(seed)) {
 129                         ll_srand(seed[0], seed[1]);
 130                         return;
 131                 }
 132                 syscall(SYS_close, _rand_dev_fd);
 133         }
 134 #endif /* LIBLUSTRE_USE_URANDOM */
 135
 136 #ifdef HAVE_GETHOSTBYNAME
 137         seed[0] = get_ipv4_addr();
 138 #else
 139         seed[0] = _my_pnid;
 140 #endif
 141         gettimeofday(&tv, NULL);
 142         ll_srand(tv.tv_sec ^ __swab32(seed[0]), tv.tv_usec ^__swab32(getpid()));
 143 }
 144
 145 static void init_capability(__u32 *res)
 146 {
 147 #ifdef HAVE_LIBCAP
 148         cap_t syscap;
 149         cap_flag_value_t capval;
 150         int i;
 151
 152         *res = 0;
 153
 154         syscap = cap_get_proc();
 155         if (!syscap) {
 156                 CWARN("Warning: failed to get system capability, "
 157                       "set to minimal\n");
 158                 return;
 159         }
 160
 161         for (i = 0; i < sizeof(cap_value_t) * 8; i++) {
 162                 if (!cap_get_flag(syscap, i, CAP_EFFECTIVE, &capval)) {
 163                         if (capval == CAP_SET) {
 164                                 *res |= 1 << i;
 165                         }
 166                 }
 167         }
 168 #else
 169         /*
 170          * set fake cap flags to ship to linux server
 171          * from client platforms that have none (eg. catamount)
 172          *  full capability for root
 173          *  no capability for anybody else
 174          */
 175 #define FAKE_ROOT_CAP 0x1ffffeff
 176 #define FAKE_USER_CAP 0
 177
 178         *res = (current->fsuid == 0) ? FAKE_ROOT_CAP: FAKE_USER_CAP;
 179 #endif
 180 }
 181
 182 int in_group_p(gid_t gid)
 183 {
 184         int i;
 185
 186         if (gid == current->fsgid)
 187                 return 1;
 188
 189         for (i = 0; i < current->ngroups; i++) {
 190                 if (gid == current->groups[i])
 191                         return 1;
 192         }
 193
 194         return 0;
 195 }
 196
 197 int liblustre_init_current(char *comm)
 198 {
 199         current = malloc(sizeof(*current));
 200         if (!current) {
 201                 CERROR("Not enough memory\n");
 202                 return -ENOMEM;
 203         }
 204
 205         strncpy(current->comm, comm, sizeof(current->comm));
 206         current->pid = getpid();
 207         current->fsuid = geteuid();
 208         current->fsgid = getegid();
 209         memset(&current->pending, 0, sizeof(current->pending));
 210
 211         current->max_groups = sysconf(_SC_NGROUPS_MAX);
 212         current->groups = malloc(sizeof(gid_t) * current->max_groups);
 213         if (!current->groups) {
 214                 CERROR("Not enough memory\n");
 215                 return -ENOMEM;
 216         }
 217         current->ngroups = getgroups(current->max_groups, current->groups);
 218         if (current->ngroups < 0) {
 219                 perror("Error getgroups");
 220                 return -EINVAL;
 221         }
 222
 223         init_capability(&current->cap_effective);
 224
 225         return 0;
 226 }
 227
 228 void cfs_cap_raise(cfs_cap_t cap)
 229 {
 230         current->cap_effective |= (1 << cap);
 231 }
 232
 233 void cfs_cap_lower(cfs_cap_t cap)
 234 {
 235         current->cap_effective &= ~(1 << cap);
 236 }
 237
 238 int cfs_cap_raised(cfs_cap_t cap)
 239 {
 240         return current->cap_effective & (1 << cap);
 241 }
 242
 243 void cfs_kernel_cap_pack(cfs_kernel_cap_t kcap, cfs_cap_t *cap)
 244 {
 245         *cap = kcap;
 246 }
 247
 248 void cfs_kernel_cap_unpack(cfs_kernel_cap_t *kcap, cfs_cap_t cap)
 249 {
 250         *kcap = cap;
 251 }
 252
 253 cfs_cap_t cfs_curproc_cap_pack(void) {
 254         cfs_cap_t cap;
 255         cfs_kernel_cap_pack(cfs_current()->cap_effective, &cap);
 256         return cap;
 257 }
 258
 259 void cfs_curproc_cap_unpack(cfs_cap_t cap) {
 260         cfs_kernel_cap_unpack(&cfs_current()->cap_effective, cap);
 261 }
 262
 263 int cfs_capable(cfs_cap_t cap)
 264 {
 265         return cfs_cap_raised(cap);
 266 }
 267
 268 int init_lib_portals()
 269 {
 270         int rc;
 271         ENTRY;
 272
 273         rc = libcfs_debug_init(5 * 1024 * 1024);
 274         if (rc != 0) {
 275                 CERROR("libcfs_debug_init() failed: %d\n", rc);
 276                 RETURN (-ENXIO);
 277         }
 278
 279         rc = LNetInit();
 280         if (rc != 0) {
 281                 CERROR("LNetInit() failed: %d\n", rc);
 282                 RETURN (-ENXIO);
 283         }
 284         RETURN(0);
 285 }
 286
 287 extern void ptlrpc_exit_portals(void);
 288 void cleanup_lib_portals()
 289 {
 290         libcfs_debug_cleanup();
 291         ptlrpc_exit_portals();
 292 }