Linux 4.13: use designated initializers where required
[openafs.git] / src / afs / LINUX / osi_misc.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Linux support routines.
12  *
13  */
14 #include <afsconfig.h>
15 #include "afs/param.h"
16
17
18 #include <linux/module.h> /* early to avoid printf->printk mapping */
19 #include <linux/dcache.h>
20 #include <linux/namei.h>
21 #include <linux/kthread.h>
22 #include "afs/sysincludes.h"
23 #include "afsincludes.h"
24 #include "afs/afs_stats.h"
25
26 #include "osi_compat.h"
27
28 int afs_osicred_initialized = 0;
29 afs_ucred_t afs_osi_cred;
30
31 void
32 afs_osi_SetTime(osi_timeval_t * tvp)
33 {
34     struct timespec tv;
35     tv.tv_sec = tvp->tv_sec;
36     tv.tv_nsec = tvp->tv_usec * NSEC_PER_USEC;
37
38     AFS_STATCNT(osi_SetTime);
39
40     do_settimeofday(&tv);
41 }
42
43 void
44 osi_linux_mask(void)
45 {
46     SIG_LOCK(current);
47     sigfillset(&current->blocked);
48     RECALC_SIGPENDING(current);
49     SIG_UNLOCK(current);
50 }
51
52 /* LOOKUP_POSITIVE is becoming the default */
53 #ifndef LOOKUP_POSITIVE
54 #define LOOKUP_POSITIVE 0
55 #endif
56 /* Lookup name and return vnode for same. */
57 int
58 osi_lookupname_internal(char *aname, int followlink, struct vfsmount **mnt,
59                         struct dentry **dpp)
60 {
61     int code;
62 #if defined(HAVE_LINUX_PATH_LOOKUP)
63     struct nameidata path_data;
64 #else
65     afs_linux_path_t path_data;
66 #endif
67     int flags = LOOKUP_POSITIVE;
68
69     if (followlink)
70        flags |= LOOKUP_FOLLOW;
71     code = afs_kern_path(aname, flags, &path_data);
72
73     if (!code)
74         afs_get_dentry_ref(&path_data, mnt, dpp);
75
76     return code;
77 }
78
79 static char *
80 afs_getname(char *aname)
81 {
82     int len;
83     char *name = kmem_cache_alloc(names_cachep, GFP_KERNEL);
84
85     if (!name)
86         return ERR_PTR(-ENOMEM);
87
88     len = strncpy_from_user(name, aname, PATH_MAX);
89     if (len < 0)
90         goto error;
91     if (len >= PATH_MAX) {
92         len = -ENAMETOOLONG;
93         goto error;
94     }
95     return name;
96
97 error:
98     kmem_cache_free(names_cachep, name);
99     return ERR_PTR(len);
100 }
101
102 static void
103 afs_putname(char *name)
104 {
105     kmem_cache_free(names_cachep, name);
106 }
107
108 int
109 osi_lookupname(char *aname, uio_seg_t seg, int followlink,
110                struct dentry **dpp)
111 {
112     int code;
113     char *name;
114
115     if (seg == AFS_UIOUSER) {
116         name = afs_getname(aname);
117         if (IS_ERR(name))
118             return -PTR_ERR(name);
119     } else {
120         name = aname;
121     }
122     code = osi_lookupname_internal(name, followlink, NULL, dpp);
123     if (seg == AFS_UIOUSER) {
124         afs_putname(name);
125     }
126     return code;
127 }
128
129 int osi_abspath(char *aname, char *buf, int buflen,
130                 int followlink, char **pathp)
131 {
132     struct dentry *dp = NULL;
133     struct vfsmount *mnt = NULL;
134     char *name, *path;
135     int code;
136
137     name = afs_getname(aname);
138     if (IS_ERR(name))
139         return -PTR_ERR(name);
140     code = osi_lookupname_internal(name, followlink, &mnt, &dp);
141     if (!code) {
142 #if defined(D_PATH_TAKES_STRUCT_PATH)
143         afs_linux_path_t p = { .mnt = mnt, .dentry = dp };
144         path = d_path(&p, buf, buflen);
145 #else
146         path = d_path(dp, mnt, buf, buflen);
147 #endif
148
149         if (IS_ERR(path)) {
150             code = -PTR_ERR(path);
151         } else {
152             *pathp = path;
153         }
154
155         dput(dp);
156         mntput(mnt);
157     }
158
159     afs_putname(name);
160     return code;
161 }
162
163
164 /* This could use some work, and support on more platforms. */
165 int afs_thread_wrapper(void *rock)
166 {
167     void (*proc)(void) = rock;
168     __module_get(THIS_MODULE);
169     AFS_GLOCK();
170     (*proc)();
171     AFS_GUNLOCK();
172     module_put(THIS_MODULE);
173     return 0;
174 }
175
176 void afs_start_thread(void (*proc)(void), char *name)
177 {
178     kthread_run(afs_thread_wrapper, proc, "%s", name);
179 }