libcfs/libcfs/linux/linux-prim.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.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2013, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  */
  32
  33 #define DEBUG_SUBSYSTEM S_LNET
  34
  35 #include <linux/kallsyms.h>
  36 #include <linux/module.h>
  37 #include <linux/kernel.h>
  38 #include <linux/fs.h>
  39 #include <linux/fs_struct.h>
  40 #include <linux/sched.h>
  41 #ifdef HAVE_SCHED_HEADERS
  42 #include <linux/sched/signal.h>
  43 #include <linux/sched/mm.h>
  44 #endif
  45 #include <linux/uaccess.h>
  46
  47 #if defined(CONFIG_KGDB)
  48 #include <asm/kgdb.h>
  49 #endif
  50
  51 #include <libcfs/linux/linux-time.h>
  52 #include <libcfs/linux/linux-wait.h>
  53
  54 #ifndef HAVE_KTIME_GET_TS64
  55 void ktime_get_ts64(struct timespec64 *ts)
  56 {
  57         struct timespec now;
  58
  59         ktime_get_ts(&now);
  60         *ts = timespec_to_timespec64(now);
  61 }
  62 EXPORT_SYMBOL(ktime_get_ts64);
  63 #endif /* HAVE_KTIME_GET_TS64 */
  64
  65 #ifndef HAVE_KTIME_GET_REAL_TS64
  66 void ktime_get_real_ts64(struct timespec64 *ts)
  67 {
  68         struct timespec now;
  69
  70         getnstimeofday(&now);
  71         *ts = timespec_to_timespec64(now);
  72 }
  73 EXPORT_SYMBOL(ktime_get_real_ts64);
  74 #endif /* HAVE_KTIME_GET_REAL_TS64 */
  75
  76 #ifndef HAVE_KTIME_GET_REAL_SECONDS
  77 /*
  78  * Get the seconds portion of CLOCK_REALTIME (wall clock).
  79  * This is the clock that can be altered by NTP and is
  80  * independent of a reboot.
  81  */
  82 time64_t ktime_get_real_seconds(void)
  83 {
  84         return (time64_t)get_seconds();
  85 }
  86 EXPORT_SYMBOL(ktime_get_real_seconds);
  87 #endif /* HAVE_KTIME_GET_REAL_SECONDS */
  88
  89 #ifndef HAVE_KTIME_GET_SECONDS
  90 /*
  91  * Get the seconds portion of CLOCK_MONOTONIC
  92  * This clock is immutable and is reset across
  93  * reboots. For older platforms this is a
  94  * wrapper around get_seconds which is valid
  95  * until 2038. By that time this will be gone
  96  * one would hope.
  97  */
  98 time64_t ktime_get_seconds(void)
  99 {
 100         struct timespec64 now;
 101
 102         ktime_get_ts64(&now);
 103         return now.tv_sec;
 104 }
 105 EXPORT_SYMBOL(ktime_get_seconds);
 106 #endif /* HAVE_KTIME_GET_SECONDS */
 107
 108 static int (*cfs_apply_workqueue_attrs_t)(struct workqueue_struct *wq,
 109                                           const struct workqueue_attrs *attrs);
 110
 111 int cfs_apply_workqueue_attrs(struct workqueue_struct *wq,
 112                               const struct workqueue_attrs *attrs)
 113 {
 114         return cfs_apply_workqueue_attrs_t(wq, attrs);
 115 }
 116 EXPORT_SYMBOL_GPL(cfs_apply_workqueue_attrs);
 117
 118 struct kmem_cache (*cfs_radix_tree_node_cachep);
 119
 120 void __init cfs_arch_init(void)
 121 {
 122 #ifndef HAVE_WAIT_VAR_EVENT
 123         wait_bit_init();
 124 #endif
 125         cfs_apply_workqueue_attrs_t =
 126                 (void *)kallsyms_lookup_name("apply_workqueue_attrs");
 127 }
 128
 129 int cfs_kernel_write(struct file *filp, const void *buf, size_t count,
 130                      loff_t *pos)
 131 {
 132 #ifdef HAVE_NEW_KERNEL_WRITE
 133         return kernel_write(filp, buf, count, pos);
 134 #else
 135         mm_segment_t __old_fs = get_fs();
 136         int rc;
 137
 138         set_fs(KERNEL_DS);
 139         rc = vfs_write(filp, (__force const char __user *)buf, count, pos);
 140         set_fs(__old_fs);
 141
 142         return rc;
 143 #endif
 144 }
 145 EXPORT_SYMBOL(cfs_kernel_write);
 146
 147 ssize_t cfs_kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
 148 {
 149 #ifdef HAVE_KERNEL_READ_LAST_POSP
 150         return kernel_read(file, buf, count, pos);
 151 #else
 152         ssize_t size = kernel_read(file, *pos, buf, count);
 153
 154         if (size > 0)
 155                 *pos += size;
 156         return size;
 157 #endif
 158 }
 159 EXPORT_SYMBOL(cfs_kernel_read);
 160
 161 #ifndef HAVE_KSET_FIND_OBJ
 162 struct kobject *kset_find_obj(struct kset *kset, const char *name)
 163 {
 164         struct kobject *ret = NULL;
 165         struct kobject *k;
 166
 167         spin_lock(&kset->list_lock);
 168
 169         list_for_each_entry(k, &kset->list, entry) {
 170                 if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
 171                         if (kref_get_unless_zero(&k->kref))
 172                                 ret = k;
 173                         break;
 174                 }
 175         }
 176
 177         spin_unlock(&kset->list_lock);
 178         return ret;
 179 }
 180 EXPORT_SYMBOL_GPL(kset_find_obj);
 181 #endif
 182
 183 #ifndef HAVE_KSTRTOBOOL_FROM_USER
 184 int kstrtobool_from_user(const char __user *s, size_t count, bool *res)
 185 {
 186         /* Longest string needed to differentiate, newline, terminator */
 187         char buf[4];
 188
 189         count = min(count, sizeof(buf) - 1);
 190         if (copy_from_user(buf, s, count))
 191                 return -EFAULT;
 192         buf[count] = '\0';
 193         return strtobool(buf, res);
 194 }
 195 EXPORT_SYMBOL(kstrtobool_from_user);
 196 #endif /* !HAVE_KSTRTOBOOL_FROM_USER */
 197
 198 /* Block all signals except for the @sigs */
 199 sigset_t cfs_block_sigsinv(unsigned long sigs)
 200 {
 201         unsigned long flags;
 202         sigset_t old;
 203
 204         spin_lock_irqsave(&current->sighand->siglock, flags);
 205         old = current->blocked;
 206         sigaddsetmask(&current->blocked, ~sigs);
 207         recalc_sigpending();
 208         spin_unlock_irqrestore(&current->sighand->siglock, flags);
 209         return old;
 210 }
 211 EXPORT_SYMBOL(cfs_block_sigsinv);
 212
 213 void
 214 cfs_restore_sigs(sigset_t old)
 215 {
 216         unsigned long  flags;
 217
 218         spin_lock_irqsave(&current->sighand->siglock, flags);
 219         current->blocked = old;
 220         recalc_sigpending();
 221         spin_unlock_irqrestore(&current->sighand->siglock, flags);
 222 }
 223 EXPORT_SYMBOL(cfs_restore_sigs);