1 | /* $Id: utils.c 79594 2019-07-08 13:40:15Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * vboxsf - VBox Linux Shared Folders VFS, utility functions.
|
---|
4 | *
|
---|
5 | * Utility functions (mainly conversion from/to VirtualBox/Linux data structures).
|
---|
6 | */
|
---|
7 |
|
---|
8 | /*
|
---|
9 | * Copyright (C) 2006-2019 Oracle Corporation
|
---|
10 | *
|
---|
11 | * Permission is hereby granted, free of charge, to any person
|
---|
12 | * obtaining a copy of this software and associated documentation
|
---|
13 | * files (the "Software"), to deal in the Software without
|
---|
14 | * restriction, including without limitation the rights to use,
|
---|
15 | * copy, modify, merge, publish, distribute, sublicense, and/or sell
|
---|
16 | * copies of the Software, and to permit persons to whom the
|
---|
17 | * Software is furnished to do so, subject to the following
|
---|
18 | * conditions:
|
---|
19 | *
|
---|
20 | * The above copyright notice and this permission notice shall be
|
---|
21 | * included in all copies or substantial portions of the Software.
|
---|
22 | *
|
---|
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
---|
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
---|
25 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
---|
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
---|
27 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
---|
28 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
---|
29 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
---|
30 | * OTHER DEALINGS IN THE SOFTWARE.
|
---|
31 | */
|
---|
32 |
|
---|
33 | #include "vfsmod.h"
|
---|
34 | #include <iprt/asm.h>
|
---|
35 | #include <iprt/err.h>
|
---|
36 | #include <linux/vfs.h>
|
---|
37 |
|
---|
38 |
|
---|
39 | int vbsf_nlscpy(struct vbsf_super_info *pSuperInfo, char *name, size_t name_bound_len,
|
---|
40 | const unsigned char *utf8_name, size_t utf8_len)
|
---|
41 | {
|
---|
42 | Assert(name_bound_len > 1);
|
---|
43 | Assert(RTStrNLen(utf8_name, utf8_len) == utf8_len);
|
---|
44 |
|
---|
45 | if (pSuperInfo->nls) {
|
---|
46 | const char *in = utf8_name;
|
---|
47 | size_t in_bound_len = utf8_len;
|
---|
48 | char *out = name;
|
---|
49 | size_t out_bound_len = name_bound_len - 1;
|
---|
50 | size_t out_len = 0;
|
---|
51 |
|
---|
52 | while (in_bound_len) {
|
---|
53 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
|
---|
54 | unicode_t uni;
|
---|
55 | int cbInEnc = utf8_to_utf32(in, in_bound_len, &uni);
|
---|
56 | #else
|
---|
57 | linux_wchar_t uni;
|
---|
58 | int cbInEnc = utf8_mbtowc(&uni, in, in_bound_len);
|
---|
59 | #endif
|
---|
60 | if (cbInEnc >= 0) {
|
---|
61 | int cbOutEnc = pSuperInfo->nls->uni2char(uni, out, out_bound_len);
|
---|
62 | if (cbOutEnc >= 0) {
|
---|
63 | /*SFLOG3(("vbsf_nlscpy: cbOutEnc=%d cbInEnc=%d uni=%#x in_bound_len=%u\n", cbOutEnc, cbInEnc, uni, in_bound_len));*/
|
---|
64 | out += cbOutEnc;
|
---|
65 | out_bound_len -= cbOutEnc;
|
---|
66 | out_len += cbOutEnc;
|
---|
67 |
|
---|
68 | in += cbInEnc;
|
---|
69 | in_bound_len -= cbInEnc;
|
---|
70 | } else {
|
---|
71 | SFLOG(("vbsf_nlscpy: nls->uni2char failed with %d on %#x (pos %u in '%s'), out_bound_len=%u\n",
|
---|
72 | cbOutEnc, uni, in - (const char *)utf8_name, (const char *)utf8_name, (unsigned)out_bound_len));
|
---|
73 | return cbOutEnc;
|
---|
74 | }
|
---|
75 | } else {
|
---|
76 | SFLOG(("vbsf_nlscpy: utf8_to_utf32/utf8_mbtowc failed with %d on %x (pos %u in '%s'), in_bound_len=%u!\n",
|
---|
77 | cbInEnc, *in, in - (const char *)utf8_name, (const char *)utf8_name, (unsigned)in_bound_len));
|
---|
78 | return -EINVAL;
|
---|
79 | }
|
---|
80 | }
|
---|
81 |
|
---|
82 | *out = '\0';
|
---|
83 | } else {
|
---|
84 | if (utf8_len + 1 > name_bound_len)
|
---|
85 | return -ENAMETOOLONG;
|
---|
86 |
|
---|
87 | memcpy(name, utf8_name, utf8_len + 1);
|
---|
88 | }
|
---|
89 | return 0;
|
---|
90 | }
|
---|
91 |
|
---|
92 |
|
---|
93 | /**
|
---|
94 | * Converts the given NLS string to a host one, kmalloc'ing
|
---|
95 | * the output buffer (use kfree on result).
|
---|
96 | */
|
---|
97 | int vbsf_nls_to_shflstring(struct vbsf_super_info *pSuperInfo, const char *pszNls, PSHFLSTRING *ppString)
|
---|
98 | {
|
---|
99 | int rc;
|
---|
100 | size_t const cchNls = strlen(pszNls);
|
---|
101 | PSHFLSTRING pString = NULL;
|
---|
102 | if (pSuperInfo->nls) {
|
---|
103 | /*
|
---|
104 | * NLS -> UTF-8 w/ SHLF string header.
|
---|
105 | */
|
---|
106 | /* Calc length first: */
|
---|
107 | size_t cchUtf8 = 0;
|
---|
108 | size_t offNls = 0;
|
---|
109 | while (offNls < cchNls) {
|
---|
110 | linux_wchar_t uc; /* Note! We renamed the type due to clashes. */
|
---|
111 | int const cbNlsCodepoint = pSuperInfo->nls->char2uni(&pszNls[offNls], cchNls - offNls, &uc);
|
---|
112 | if (cbNlsCodepoint >= 0) {
|
---|
113 | char achTmp[16];
|
---|
114 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
|
---|
115 | int cbUtf8Codepoint = utf32_to_utf8(uc, achTmp, sizeof(achTmp));
|
---|
116 | #else
|
---|
117 | int cbUtf8Codepoint = utf8_wctomb(achTmp, uc, sizeof(achTmp));
|
---|
118 | #endif
|
---|
119 | if (cbUtf8Codepoint > 0) {
|
---|
120 | cchUtf8 += cbUtf8Codepoint;
|
---|
121 | offNls += cbNlsCodepoint;
|
---|
122 | } else {
|
---|
123 | Log(("vbsf_nls_to_shflstring: nls->uni2char(%#x) failed: %d\n", uc, cbUtf8Codepoint));
|
---|
124 | return -EINVAL;
|
---|
125 | }
|
---|
126 | } else {
|
---|
127 | Log(("vbsf_nls_to_shflstring: nls->char2uni(%.*Rhxs) failed: %d\n",
|
---|
128 | RT_MIN(8, cchNls - offNls), &pszNls[offNls], cbNlsCodepoint));
|
---|
129 | return -EINVAL;
|
---|
130 | }
|
---|
131 | }
|
---|
132 | if (cchUtf8 + 1 < _64K) {
|
---|
133 | /* Allocate: */
|
---|
134 | pString = (PSHFLSTRING)kmalloc(SHFLSTRING_HEADER_SIZE + cchUtf8 + 1, GFP_KERNEL);
|
---|
135 | if (pString) {
|
---|
136 | char *pchDst = pString->String.ach;
|
---|
137 | pString->u16Length = (uint16_t)cchUtf8;
|
---|
138 | pString->u16Size = (uint16_t)(cchUtf8 + 1);
|
---|
139 |
|
---|
140 | /* Do the conversion (cchUtf8 is counted down): */
|
---|
141 | rc = 0;
|
---|
142 | offNls = 0;
|
---|
143 | while (offNls < cchNls) {
|
---|
144 | linux_wchar_t uc; /* Note! We renamed the type due to clashes. */
|
---|
145 | int const cbNlsCodepoint = pSuperInfo->nls->char2uni(&pszNls[offNls], cchNls - offNls, &uc);
|
---|
146 | if (cbNlsCodepoint >= 0) {
|
---|
147 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
|
---|
148 | int cbUtf8Codepoint = utf32_to_utf8(uc, pchDst, cchUtf8);
|
---|
149 | #else
|
---|
150 | int cbUtf8Codepoint = utf8_wctomb(pchDst, uc, cchUtf8);
|
---|
151 | #endif
|
---|
152 | if (cbUtf8Codepoint > 0) {
|
---|
153 | AssertBreakStmt(cbUtf8Codepoint <= cchUtf8, rc = -EINVAL);
|
---|
154 | cchUtf8 -= cbUtf8Codepoint;
|
---|
155 | pchDst += cbUtf8Codepoint;
|
---|
156 | offNls += cbNlsCodepoint;
|
---|
157 | } else {
|
---|
158 | Log(("vbsf_nls_to_shflstring: nls->uni2char(%#x) failed! %d, cchUtf8=%zu\n",
|
---|
159 | uc, cbUtf8Codepoint, cchUtf8));
|
---|
160 | rc = -EINVAL;
|
---|
161 | break;
|
---|
162 | }
|
---|
163 | } else {
|
---|
164 | Log(("vbsf_nls_to_shflstring: nls->char2uni(%.*Rhxs) failed! %d\n",
|
---|
165 | RT_MIN(8, cchNls - offNls), &pszNls[offNls], cbNlsCodepoint));
|
---|
166 | rc = -EINVAL;
|
---|
167 | break;
|
---|
168 | }
|
---|
169 | }
|
---|
170 | if (rc == 0) {
|
---|
171 | /*
|
---|
172 | * Succeeded. Just terminate the string and we're good.
|
---|
173 | */
|
---|
174 | Assert(pchDst - pString->String.ach == pString->u16Length);
|
---|
175 | *pchDst = '\0';
|
---|
176 | } else {
|
---|
177 | kfree(pString);
|
---|
178 | pString = NULL;
|
---|
179 | }
|
---|
180 | } else {
|
---|
181 | Log(("vbsf_nls_to_shflstring: failed to allocate %u bytes\n", SHFLSTRING_HEADER_SIZE + cchUtf8 + 1));
|
---|
182 | rc = -ENOMEM;
|
---|
183 | }
|
---|
184 | } else {
|
---|
185 | Log(("vbsf_nls_to_shflstring: too long: %zu bytes (%zu nls bytes)\n", cchUtf8, cchNls));
|
---|
186 | rc = -ENAMETOOLONG;
|
---|
187 | }
|
---|
188 | } else {
|
---|
189 | /*
|
---|
190 | * UTF-8 -> UTF-8 w/ SHLF string header.
|
---|
191 | */
|
---|
192 | if (cchNls + 1 < _64K) {
|
---|
193 | pString = (PSHFLSTRING)kmalloc(SHFLSTRING_HEADER_SIZE + cchNls + 1, GFP_KERNEL);
|
---|
194 | if (pString) {
|
---|
195 | pString->u16Length = (uint16_t)cchNls;
|
---|
196 | pString->u16Size = (uint16_t)(cchNls + 1);
|
---|
197 | memcpy(pString->String.ach, pszNls, cchNls);
|
---|
198 | pString->String.ach[cchNls] = '\0';
|
---|
199 | rc = 0;
|
---|
200 | } else {
|
---|
201 | Log(("vbsf_nls_to_shflstring: failed to allocate %u bytes\n", SHFLSTRING_HEADER_SIZE + cchNls + 1));
|
---|
202 | rc = -ENOMEM;
|
---|
203 | }
|
---|
204 | } else {
|
---|
205 | Log(("vbsf_nls_to_shflstring: too long: %zu bytes\n", cchNls));
|
---|
206 | rc = -ENAMETOOLONG;
|
---|
207 | }
|
---|
208 | }
|
---|
209 | *ppString = pString;
|
---|
210 | return rc;
|
---|
211 | }
|
---|
212 |
|
---|
213 |
|
---|
214 | /**
|
---|
215 | * Convert from VBox to linux time.
|
---|
216 | */
|
---|
217 | #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
|
---|
218 | DECLINLINE(void) vbsf_time_to_linux(time_t *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
|
---|
219 | {
|
---|
220 | int64_t t = RTTimeSpecGetNano(pVBoxSrc);
|
---|
221 | do_div(t, RT_NS_1SEC);
|
---|
222 | *pLinuxDst = t;
|
---|
223 | }
|
---|
224 | #else /* >= 2.6.0 */
|
---|
225 | # if LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0)
|
---|
226 | DECLINLINE(void) vbsf_time_to_linux(struct timespec *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
|
---|
227 | # else
|
---|
228 | DECLINLINE(void) vbsf_time_to_linux(struct timespec64 *pLinuxDst, PCRTTIMESPEC pVBoxSrc)
|
---|
229 | # endif
|
---|
230 | {
|
---|
231 | int64_t t = RTTimeSpecGetNano(pVBoxSrc);
|
---|
232 | pLinuxDst->tv_nsec = do_div(t, RT_NS_1SEC);
|
---|
233 | pLinuxDst->tv_sec = t;
|
---|
234 | }
|
---|
235 | #endif /* >= 2.6.0 */
|
---|
236 |
|
---|
237 |
|
---|
238 | /**
|
---|
239 | * Convert from linux to VBox time.
|
---|
240 | */
|
---|
241 | #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
|
---|
242 | DECLINLINE(void) vbsf_time_to_vbox(PRTTIMESPEC pVBoxDst, time_t *pLinuxSrc)
|
---|
243 | {
|
---|
244 | RTTimeSpecSetNano(pVBoxDst, RT_NS_1SEC_64 * *pLinuxSrc);
|
---|
245 | }
|
---|
246 | #else /* >= 2.6.0 */
|
---|
247 | # if LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0)
|
---|
248 | DECLINLINE(void) vbsf_time_to_vbox(PRTTIMESPEC pVBoxDst, struct timespec const *pLinuxSrc)
|
---|
249 | # else
|
---|
250 | DECLINLINE(void) vbsf_time_to_vbox(PRTTIMESPEC pVBoxDst, struct timespec64 const *pLinuxSrc)
|
---|
251 | # endif
|
---|
252 | {
|
---|
253 | RTTimeSpecSetNano(pVBoxDst, pLinuxSrc->tv_nsec + pLinuxSrc->tv_sec * (int64_t)RT_NS_1SEC);
|
---|
254 | }
|
---|
255 | #endif /* >= 2.6.0 */
|
---|
256 |
|
---|
257 |
|
---|
258 | /**
|
---|
259 | * Converts VBox access permissions to Linux ones (mode & 0777).
|
---|
260 | *
|
---|
261 | * @note Currently identical.
|
---|
262 | * @sa sf_access_permissions_to_vbox
|
---|
263 | */
|
---|
264 | DECLINLINE(int) sf_access_permissions_to_linux(uint32_t fAttr)
|
---|
265 | {
|
---|
266 | /* Access bits should be the same: */
|
---|
267 | AssertCompile(RTFS_UNIX_IRUSR == S_IRUSR);
|
---|
268 | AssertCompile(RTFS_UNIX_IWUSR == S_IWUSR);
|
---|
269 | AssertCompile(RTFS_UNIX_IXUSR == S_IXUSR);
|
---|
270 | AssertCompile(RTFS_UNIX_IRGRP == S_IRGRP);
|
---|
271 | AssertCompile(RTFS_UNIX_IWGRP == S_IWGRP);
|
---|
272 | AssertCompile(RTFS_UNIX_IXGRP == S_IXGRP);
|
---|
273 | AssertCompile(RTFS_UNIX_IROTH == S_IROTH);
|
---|
274 | AssertCompile(RTFS_UNIX_IWOTH == S_IWOTH);
|
---|
275 | AssertCompile(RTFS_UNIX_IXOTH == S_IXOTH);
|
---|
276 |
|
---|
277 | return fAttr & RTFS_UNIX_ALL_ACCESS_PERMS;
|
---|
278 | }
|
---|
279 |
|
---|
280 |
|
---|
281 | /**
|
---|
282 | * Produce the Linux mode mask, given VBox, mount options and file type.
|
---|
283 | */
|
---|
284 | DECLINLINE(int) sf_file_mode_to_linux(uint32_t fVBoxMode, int fFixedMode, int fClearMask, int fType)
|
---|
285 | {
|
---|
286 | int fLnxMode = sf_access_permissions_to_linux(fVBoxMode);
|
---|
287 | if (fFixedMode != ~0)
|
---|
288 | fLnxMode = fFixedMode & 0777;
|
---|
289 | fLnxMode &= ~fClearMask;
|
---|
290 | fLnxMode |= fType;
|
---|
291 | return fLnxMode;
|
---|
292 | }
|
---|
293 |
|
---|
294 |
|
---|
295 | /**
|
---|
296 | * Initializes the @a inode attributes based on @a pObjInfo and @a pSuperInfo
|
---|
297 | * options.
|
---|
298 | */
|
---|
299 | void vbsf_init_inode(struct inode *inode, struct vbsf_inode_info *sf_i, PSHFLFSOBJINFO pObjInfo,
|
---|
300 | struct vbsf_super_info *pSuperInfo)
|
---|
301 | {
|
---|
302 | PCSHFLFSOBJATTR pAttr = &pObjInfo->Attr;
|
---|
303 |
|
---|
304 | TRACE();
|
---|
305 |
|
---|
306 | sf_i->ts_up_to_date = jiffies;
|
---|
307 | sf_i->force_restat = 0;
|
---|
308 |
|
---|
309 | if (RTFS_IS_DIRECTORY(pAttr->fMode)) {
|
---|
310 | inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->dmode, pSuperInfo->dmask, S_IFDIR);
|
---|
311 | inode->i_op = &vbsf_dir_iops;
|
---|
312 | inode->i_fop = &vbsf_dir_fops;
|
---|
313 |
|
---|
314 | /* XXX: this probably should be set to the number of entries
|
---|
315 | in the directory plus two (. ..) */
|
---|
316 | set_nlink(inode, 1);
|
---|
317 | }
|
---|
318 | else if (RTFS_IS_SYMLINK(pAttr->fMode)) {
|
---|
319 | /** @todo r=bird: Aren't System V symlinks w/o any mode mask? IIRC there is
|
---|
320 | * no lchmod on Linux. */
|
---|
321 | inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFLNK);
|
---|
322 | inode->i_op = &vbsf_lnk_iops;
|
---|
323 | set_nlink(inode, 1);
|
---|
324 | } else {
|
---|
325 | inode->i_mode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFREG);
|
---|
326 | inode->i_op = &vbsf_reg_iops;
|
---|
327 | inode->i_fop = &vbsf_reg_fops;
|
---|
328 | inode->i_mapping->a_ops = &vbsf_reg_aops;
|
---|
329 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 17) \
|
---|
330 | && LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
|
---|
331 | inode->i_mapping->backing_dev_info = &pSuperInfo->bdi; /* This is needed for mmap. */
|
---|
332 | #endif
|
---|
333 | set_nlink(inode, 1);
|
---|
334 | }
|
---|
335 |
|
---|
336 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
|
---|
337 | inode->i_uid = make_kuid(current_user_ns(), pSuperInfo->uid);
|
---|
338 | inode->i_gid = make_kgid(current_user_ns(), pSuperInfo->gid);
|
---|
339 | #else
|
---|
340 | inode->i_uid = pSuperInfo->uid;
|
---|
341 | inode->i_gid = pSuperInfo->gid;
|
---|
342 | #endif
|
---|
343 |
|
---|
344 | inode->i_size = pObjInfo->cbObject;
|
---|
345 | #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19) && !defined(KERNEL_FC6)
|
---|
346 | inode->i_blksize = 4096;
|
---|
347 | #endif
|
---|
348 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 11)
|
---|
349 | inode->i_blkbits = 12;
|
---|
350 | #endif
|
---|
351 | /* i_blocks always in units of 512 bytes! */
|
---|
352 | inode->i_blocks = (pObjInfo->cbAllocated + 511) / 512;
|
---|
353 |
|
---|
354 | vbsf_time_to_linux(&inode->i_atime, &pObjInfo->AccessTime);
|
---|
355 | vbsf_time_to_linux(&inode->i_ctime, &pObjInfo->ChangeTime);
|
---|
356 | vbsf_time_to_linux(&inode->i_mtime, &pObjInfo->ModificationTime);
|
---|
357 | sf_i->BirthTime = pObjInfo->BirthTime;
|
---|
358 | sf_i->ModificationTime = pObjInfo->ModificationTime;
|
---|
359 | RTTimeSpecSetSeconds(&sf_i->ModificationTimeAtOurLastWrite, 0);
|
---|
360 | }
|
---|
361 |
|
---|
362 |
|
---|
363 | /**
|
---|
364 | * Update the inode with new object info from the host.
|
---|
365 | *
|
---|
366 | * Called by sf_inode_revalidate() and sf_inode_revalidate_with_handle().
|
---|
367 | */
|
---|
368 | void vbsf_update_inode(struct inode *pInode, struct vbsf_inode_info *pInodeInfo, PSHFLFSOBJINFO pObjInfo,
|
---|
369 | struct vbsf_super_info *pSuperInfo, bool fInodeLocked, unsigned fSetAttrs)
|
---|
370 | {
|
---|
371 | PCSHFLFSOBJATTR pAttr = &pObjInfo->Attr;
|
---|
372 | int fMode;
|
---|
373 |
|
---|
374 | TRACE();
|
---|
375 |
|
---|
376 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
|
---|
377 | if (!fInodeLocked)
|
---|
378 | inode_lock(pInode);
|
---|
379 | #endif
|
---|
380 |
|
---|
381 | /*
|
---|
382 | * Calc new mode mask and update it if it changed.
|
---|
383 | */
|
---|
384 | if (RTFS_IS_DIRECTORY(pAttr->fMode))
|
---|
385 | fMode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->dmode, pSuperInfo->dmask, S_IFDIR);
|
---|
386 | else if (RTFS_IS_SYMLINK(pAttr->fMode))
|
---|
387 | /** @todo r=bird: Aren't System V symlinks w/o any mode mask? IIRC there is
|
---|
388 | * no lchmod on Linux. */
|
---|
389 | fMode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFLNK);
|
---|
390 | else
|
---|
391 | fMode = sf_file_mode_to_linux(pAttr->fMode, pSuperInfo->fmode, pSuperInfo->fmask, S_IFREG);
|
---|
392 |
|
---|
393 | if (fMode == pInode->i_mode) {
|
---|
394 | /* likely */
|
---|
395 | } else {
|
---|
396 | if ((fMode & S_IFMT) == (pInode->i_mode & S_IFMT))
|
---|
397 | pInode->i_mode = fMode;
|
---|
398 | else {
|
---|
399 | SFLOGFLOW(("vbsf_update_inode: Changed from %o to %o (%s)\n",
|
---|
400 | pInode->i_mode & S_IFMT, fMode & S_IFMT, pInodeInfo->path->String.ach));
|
---|
401 | /** @todo we probably need to be more drastic... */
|
---|
402 | vbsf_init_inode(pInode, pInodeInfo, pObjInfo, pSuperInfo);
|
---|
403 |
|
---|
404 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
|
---|
405 | if (!fInodeLocked)
|
---|
406 | inode_unlock(pInode);
|
---|
407 | #endif
|
---|
408 | return;
|
---|
409 | }
|
---|
410 | }
|
---|
411 |
|
---|
412 | /*
|
---|
413 | * Update the sizes.
|
---|
414 | * Note! i_blocks is always in units of 512 bytes!
|
---|
415 | */
|
---|
416 | pInode->i_blocks = (pObjInfo->cbAllocated + 511) / 512;
|
---|
417 | i_size_write(pInode, pObjInfo->cbObject);
|
---|
418 |
|
---|
419 | /*
|
---|
420 | * Update the timestamps.
|
---|
421 | */
|
---|
422 | vbsf_time_to_linux(&pInode->i_atime, &pObjInfo->AccessTime);
|
---|
423 | vbsf_time_to_linux(&pInode->i_ctime, &pObjInfo->ChangeTime);
|
---|
424 | vbsf_time_to_linux(&pInode->i_mtime, &pObjInfo->ModificationTime);
|
---|
425 | pInodeInfo->BirthTime = pObjInfo->BirthTime;
|
---|
426 |
|
---|
427 | /*
|
---|
428 | * Mark it as up to date.
|
---|
429 | * Best to do this before we start with any expensive map invalidation.
|
---|
430 | */
|
---|
431 | pInodeInfo->ts_up_to_date = jiffies;
|
---|
432 | pInodeInfo->force_restat = 0;
|
---|
433 |
|
---|
434 | /*
|
---|
435 | * If the modification time changed, we may have to invalidate the page
|
---|
436 | * cache pages associated with this inode if we suspect the change was
|
---|
437 | * made by the host. How supicious we are depends on the cache mode.
|
---|
438 | *
|
---|
439 | * Note! The invalidate_inode_pages() call is pretty weak. It will _not_
|
---|
440 | * touch pages that are already mapped into an address space, but it
|
---|
441 | * will help if the file isn't currently mmap'ed or if we're in read
|
---|
442 | * or read/write caching mode.
|
---|
443 | */
|
---|
444 | if (!RTTimeSpecIsEqual(&pInodeInfo->ModificationTime, &pObjInfo->ModificationTime)) {
|
---|
445 | if (RTFS_IS_FILE(pAttr->fMode)) {
|
---|
446 | if (!(fSetAttrs & (ATTR_MTIME | ATTR_SIZE))) {
|
---|
447 | bool fInvalidate;
|
---|
448 | if (pSuperInfo->enmCacheMode == kVbsfCacheMode_None) {
|
---|
449 | fInvalidate = true; /* No-caching: always invalidate. */
|
---|
450 | } else {
|
---|
451 | if (RTTimeSpecIsEqual(&pInodeInfo->ModificationTimeAtOurLastWrite, &pInodeInfo->ModificationTime)) {
|
---|
452 | fInvalidate = false; /* Could be our write, so don't invalidate anything */
|
---|
453 | RTTimeSpecSetSeconds(&pInodeInfo->ModificationTimeAtOurLastWrite, 0);
|
---|
454 | } else {
|
---|
455 | /*RTLogBackdoorPrintf("vbsf_update_inode: Invalidating the mapping %s - %RU64 vs %RU64 vs %RU64 - %#x\n",
|
---|
456 | pInodeInfo->path->String.ach,
|
---|
457 | RTTimeSpecGetNano(&pInodeInfo->ModificationTimeAtOurLastWrite),
|
---|
458 | RTTimeSpecGetNano(&pInodeInfo->ModificationTime),
|
---|
459 | RTTimeSpecGetNano(&pObjInfo->ModificationTime), fSetAttrs);*/
|
---|
460 | fInvalidate = true; /* We haven't modified the file recently, so probably a host update. */
|
---|
461 | }
|
---|
462 | }
|
---|
463 | pInodeInfo->ModificationTime = pObjInfo->ModificationTime;
|
---|
464 |
|
---|
465 | if (fInvalidate) {
|
---|
466 | struct address_space *mapping = pInode->i_mapping;
|
---|
467 | if (mapping && mapping->nrpages > 0) {
|
---|
468 | SFLOGFLOW(("vbsf_update_inode: Invalidating the mapping %s (%#x)\n", pInodeInfo->path->String.ach, fSetAttrs));
|
---|
469 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
|
---|
470 | invalidate_mapping_pages(mapping, 0, ~(pgoff_t)0);
|
---|
471 | #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 41)
|
---|
472 | invalidate_inode_pages(mapping);
|
---|
473 | #else
|
---|
474 | invalidate_inode_pages(pInode);
|
---|
475 | #endif
|
---|
476 | }
|
---|
477 | }
|
---|
478 | } else {
|
---|
479 | RTTimeSpecSetSeconds(&pInodeInfo->ModificationTimeAtOurLastWrite, 0);
|
---|
480 | pInodeInfo->ModificationTime = pObjInfo->ModificationTime;
|
---|
481 | }
|
---|
482 | } else
|
---|
483 | pInodeInfo->ModificationTime = pObjInfo->ModificationTime;
|
---|
484 | }
|
---|
485 |
|
---|
486 | /*
|
---|
487 | * Done.
|
---|
488 | */
|
---|
489 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0)
|
---|
490 | if (!fInodeLocked)
|
---|
491 | inode_unlock(pInode);
|
---|
492 | #endif
|
---|
493 | }
|
---|
494 |
|
---|
495 |
|
---|
496 | /** @note Currently only used for the root directory during (re-)mount. */
|
---|
497 | int vbsf_stat(const char *caller, struct vbsf_super_info *pSuperInfo, SHFLSTRING *path, PSHFLFSOBJINFO result, int ok_to_fail)
|
---|
498 | {
|
---|
499 | int rc;
|
---|
500 | VBOXSFCREATEREQ *pReq;
|
---|
501 | NOREF(caller);
|
---|
502 |
|
---|
503 | TRACE();
|
---|
504 |
|
---|
505 | pReq = (VBOXSFCREATEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq) + path->u16Size);
|
---|
506 | if (pReq) {
|
---|
507 | RT_ZERO(*pReq);
|
---|
508 | memcpy(&pReq->StrPath, path, SHFLSTRING_HEADER_SIZE + path->u16Size);
|
---|
509 | pReq->CreateParms.Handle = SHFL_HANDLE_NIL;
|
---|
510 | pReq->CreateParms.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
|
---|
511 |
|
---|
512 | LogFunc(("Calling VbglR0SfHostReqCreate on %s\n", path->String.utf8));
|
---|
513 | rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
|
---|
514 | if (RT_SUCCESS(rc)) {
|
---|
515 | if (pReq->CreateParms.Result == SHFL_FILE_EXISTS) {
|
---|
516 | *result = pReq->CreateParms.Info;
|
---|
517 | rc = 0;
|
---|
518 | } else {
|
---|
519 | if (!ok_to_fail)
|
---|
520 | LogFunc(("VbglR0SfHostReqCreate on %s: file does not exist: %d (caller=%s)\n",
|
---|
521 | path->String.utf8, pReq->CreateParms.Result, caller));
|
---|
522 | rc = -ENOENT;
|
---|
523 | }
|
---|
524 | } else if (rc == VERR_INVALID_NAME) {
|
---|
525 | rc = -ENOENT; /* this can happen for names like 'foo*' on a Windows host */
|
---|
526 | } else {
|
---|
527 | LogFunc(("VbglR0SfHostReqCreate failed on %s: %Rrc (caller=%s)\n", path->String.utf8, rc, caller));
|
---|
528 | rc = -EPROTO;
|
---|
529 | }
|
---|
530 | VbglR0PhysHeapFree(pReq);
|
---|
531 | }
|
---|
532 | else
|
---|
533 | rc = -ENOMEM;
|
---|
534 | return rc;
|
---|
535 | }
|
---|
536 |
|
---|
537 |
|
---|
538 | /**
|
---|
539 | * Revalidate an inode, inner worker.
|
---|
540 | *
|
---|
541 | * @sa sf_inode_revalidate()
|
---|
542 | */
|
---|
543 | int vbsf_inode_revalidate_worker(struct dentry *dentry, bool fForced, bool fInodeLocked)
|
---|
544 | {
|
---|
545 | int rc;
|
---|
546 | struct inode *pInode = dentry ? dentry->d_inode : NULL;
|
---|
547 | if (pInode) {
|
---|
548 | struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(pInode);
|
---|
549 | struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pInode->i_sb);
|
---|
550 | AssertReturn(sf_i, -EINVAL);
|
---|
551 | AssertReturn(pSuperInfo, -EINVAL);
|
---|
552 |
|
---|
553 | /*
|
---|
554 | * Can we get away without any action here?
|
---|
555 | */
|
---|
556 | if ( !fForced
|
---|
557 | && !sf_i->force_restat
|
---|
558 | && jiffies - sf_i->ts_up_to_date < pSuperInfo->cJiffiesInodeTTL)
|
---|
559 | rc = 0;
|
---|
560 | else {
|
---|
561 | /*
|
---|
562 | * No, we have to query the file info from the host.
|
---|
563 | * Try get a handle we can query, any kind of handle will do here.
|
---|
564 | */
|
---|
565 | struct vbsf_handle *pHandle = vbsf_handle_find(sf_i, 0, 0);
|
---|
566 | if (pHandle) {
|
---|
567 | /* Query thru pHandle. */
|
---|
568 | VBOXSFOBJINFOREQ *pReq = (VBOXSFOBJINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
|
---|
569 | if (pReq) {
|
---|
570 | RT_ZERO(*pReq);
|
---|
571 | rc = VbglR0SfHostReqQueryObjInfo(pSuperInfo->map.root, pReq, pHandle->hHost);
|
---|
572 | if (RT_SUCCESS(rc)) {
|
---|
573 | /*
|
---|
574 | * Reset the TTL and copy the info over into the inode structure.
|
---|
575 | */
|
---|
576 | vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, pSuperInfo, fInodeLocked, 0 /*fSetAttrs*/);
|
---|
577 | } else if (rc == VERR_INVALID_HANDLE) {
|
---|
578 | rc = -ENOENT; /* Restore.*/
|
---|
579 | } else {
|
---|
580 | LogFunc(("VbglR0SfHostReqQueryObjInfo failed on %#RX64: %Rrc\n", pHandle->hHost, rc));
|
---|
581 | rc = -RTErrConvertToErrno(rc);
|
---|
582 | }
|
---|
583 | VbglR0PhysHeapFree(pReq);
|
---|
584 | } else
|
---|
585 | rc = -ENOMEM;
|
---|
586 | vbsf_handle_release(pHandle, pSuperInfo, "vbsf_inode_revalidate_worker");
|
---|
587 |
|
---|
588 | } else {
|
---|
589 | /* Query via path. */
|
---|
590 | SHFLSTRING *pPath = sf_i->path;
|
---|
591 | VBOXSFCREATEREQ *pReq = (VBOXSFCREATEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq) + pPath->u16Size);
|
---|
592 | if (pReq) {
|
---|
593 | RT_ZERO(*pReq);
|
---|
594 | memcpy(&pReq->StrPath, pPath, SHFLSTRING_HEADER_SIZE + pPath->u16Size);
|
---|
595 | pReq->CreateParms.Handle = SHFL_HANDLE_NIL;
|
---|
596 | pReq->CreateParms.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
|
---|
597 |
|
---|
598 | rc = VbglR0SfHostReqCreate(pSuperInfo->map.root, pReq);
|
---|
599 | if (RT_SUCCESS(rc)) {
|
---|
600 | if (pReq->CreateParms.Result == SHFL_FILE_EXISTS) {
|
---|
601 | /*
|
---|
602 | * Reset the TTL and copy the info over into the inode structure.
|
---|
603 | */
|
---|
604 | vbsf_update_inode(pInode, sf_i, &pReq->CreateParms.Info, pSuperInfo, fInodeLocked, 0 /*fSetAttrs*/);
|
---|
605 | rc = 0;
|
---|
606 | } else {
|
---|
607 | rc = -ENOENT;
|
---|
608 | }
|
---|
609 | } else if (rc == VERR_INVALID_NAME) {
|
---|
610 | rc = -ENOENT; /* this can happen for names like 'foo*' on a Windows host */
|
---|
611 | } else {
|
---|
612 | LogFunc(("VbglR0SfHostReqCreate failed on %s: %Rrc\n", pPath->String.ach, rc));
|
---|
613 | rc = -EPROTO;
|
---|
614 | }
|
---|
615 | VbglR0PhysHeapFree(pReq);
|
---|
616 | }
|
---|
617 | else
|
---|
618 | rc = -ENOMEM;
|
---|
619 | }
|
---|
620 | }
|
---|
621 | } else {
|
---|
622 | LogFunc(("no dentry(%p) or inode(%p)\n", dentry, pInode));
|
---|
623 | rc = -EINVAL;
|
---|
624 | }
|
---|
625 | return rc;
|
---|
626 | }
|
---|
627 |
|
---|
628 |
|
---|
629 | #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 18)
|
---|
630 | /**
|
---|
631 | * Revalidate an inode for 2.4.
|
---|
632 | *
|
---|
633 | * This is called in the stat(), lstat() and readlink() code paths. In the stat
|
---|
634 | * cases the caller will use the result afterwards to produce the stat data.
|
---|
635 | *
|
---|
636 | * @note 2.4.x has a getattr() inode operation too, but it is not used.
|
---|
637 | */
|
---|
638 | int vbsf_inode_revalidate(struct dentry *dentry)
|
---|
639 | {
|
---|
640 | /*
|
---|
641 | * We pretend the inode is locked here, as 2.4.x does not have inode level locking.
|
---|
642 | */
|
---|
643 | return vbsf_inode_revalidate_worker(dentry, false /*fForced*/, true /*fInodeLocked*/);
|
---|
644 | }
|
---|
645 | #endif /* < 2.5.18 */
|
---|
646 |
|
---|
647 |
|
---|
648 | /**
|
---|
649 | * Similar to sf_inode_revalidate, but uses associated host file handle as that
|
---|
650 | * is quite a bit faster.
|
---|
651 | */
|
---|
652 | int vbsf_inode_revalidate_with_handle(struct dentry *dentry, SHFLHANDLE hHostFile, bool fForced, bool fInodeLocked)
|
---|
653 | {
|
---|
654 | int err;
|
---|
655 | struct inode *pInode = dentry ? dentry->d_inode : NULL;
|
---|
656 | if (!pInode) {
|
---|
657 | LogFunc(("no dentry(%p) or inode(%p)\n", dentry, pInode));
|
---|
658 | err = -EINVAL;
|
---|
659 | } else {
|
---|
660 | struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(pInode);
|
---|
661 | struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pInode->i_sb);
|
---|
662 | AssertReturn(sf_i, -EINVAL);
|
---|
663 | AssertReturn(pSuperInfo, -EINVAL);
|
---|
664 |
|
---|
665 | /*
|
---|
666 | * Can we get away without any action here?
|
---|
667 | */
|
---|
668 | if ( !fForced
|
---|
669 | && !sf_i->force_restat
|
---|
670 | && jiffies - sf_i->ts_up_to_date < pSuperInfo->cJiffiesInodeTTL)
|
---|
671 | err = 0;
|
---|
672 | else {
|
---|
673 | /*
|
---|
674 | * No, we have to query the file info from the host.
|
---|
675 | */
|
---|
676 | VBOXSFOBJINFOREQ *pReq = (VBOXSFOBJINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
|
---|
677 | if (pReq) {
|
---|
678 | RT_ZERO(*pReq);
|
---|
679 | err = VbglR0SfHostReqQueryObjInfo(pSuperInfo->map.root, pReq, hHostFile);
|
---|
680 | if (RT_SUCCESS(err)) {
|
---|
681 | /*
|
---|
682 | * Reset the TTL and copy the info over into the inode structure.
|
---|
683 | */
|
---|
684 | vbsf_update_inode(pInode, sf_i, &pReq->ObjInfo, pSuperInfo, fInodeLocked, 0 /*fSetAttrs*/);
|
---|
685 | } else {
|
---|
686 | LogFunc(("VbglR0SfHostReqQueryObjInfo failed on %#RX64: %Rrc\n", hHostFile, err));
|
---|
687 | err = -RTErrConvertToErrno(err);
|
---|
688 | }
|
---|
689 | VbglR0PhysHeapFree(pReq);
|
---|
690 | } else
|
---|
691 | err = -ENOMEM;
|
---|
692 | }
|
---|
693 | }
|
---|
694 | return err;
|
---|
695 | }
|
---|
696 |
|
---|
697 |
|
---|
698 | /* on 2.6 this is a proxy for [sf_inode_revalidate] which (as a side
|
---|
699 | effect) updates inode attributes for [dentry] (given that [dentry]
|
---|
700 | has inode at all) from these new attributes we derive [kstat] via
|
---|
701 | [generic_fillattr] */
|
---|
702 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 18)
|
---|
703 |
|
---|
704 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
---|
705 | int vbsf_inode_getattr(const struct path *path, struct kstat *kstat, u32 request_mask, unsigned int flags)
|
---|
706 | # else
|
---|
707 | int vbsf_inode_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
|
---|
708 | # endif
|
---|
709 | {
|
---|
710 | int rc;
|
---|
711 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
---|
712 | struct dentry *dentry = path->dentry;
|
---|
713 | # endif
|
---|
714 |
|
---|
715 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
---|
716 | SFLOGFLOW(("vbsf_inode_getattr: dentry=%p request_mask=%#x flags=%#x\n", dentry, request_mask, flags));
|
---|
717 | # else
|
---|
718 | SFLOGFLOW(("vbsf_inode_getattr: dentry=%p\n", dentry));
|
---|
719 | # endif
|
---|
720 |
|
---|
721 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
---|
722 | /*
|
---|
723 | * With the introduction of statx() userland can control whether we
|
---|
724 | * update the inode information or not.
|
---|
725 | */
|
---|
726 | switch (flags & AT_STATX_SYNC_TYPE) {
|
---|
727 | default:
|
---|
728 | rc = vbsf_inode_revalidate_worker(dentry, false /*fForced*/, false /*fInodeLocked*/);
|
---|
729 | break;
|
---|
730 |
|
---|
731 | case AT_STATX_FORCE_SYNC:
|
---|
732 | rc = vbsf_inode_revalidate_worker(dentry, true /*fForced*/, false /*fInodeLocked*/);
|
---|
733 | break;
|
---|
734 |
|
---|
735 | case AT_STATX_DONT_SYNC:
|
---|
736 | rc = 0;
|
---|
737 | break;
|
---|
738 | }
|
---|
739 | # else
|
---|
740 | rc = vbsf_inode_revalidate_worker(dentry, false /*fForced*/, false /*fInodeLocked*/);
|
---|
741 | # endif
|
---|
742 | if (rc == 0) {
|
---|
743 | /* Do generic filling in of info. */
|
---|
744 | generic_fillattr(dentry->d_inode, kstat);
|
---|
745 |
|
---|
746 | /* Add birth time. */
|
---|
747 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
|
---|
748 | if (dentry->d_inode) {
|
---|
749 | struct vbsf_inode_info *pInodeInfo = VBSF_GET_INODE_INFO(dentry->d_inode);
|
---|
750 | if (pInodeInfo) {
|
---|
751 | vbsf_time_to_linux(&kstat->btime, &pInodeInfo->BirthTime);
|
---|
752 | kstat->result_mask |= STATX_BTIME;
|
---|
753 | }
|
---|
754 | }
|
---|
755 | # endif
|
---|
756 |
|
---|
757 | /*
|
---|
758 | * FsPerf shows the following numbers for sequential file access against
|
---|
759 | * a tmpfs folder on an AMD 1950X host running debian buster/sid:
|
---|
760 | *
|
---|
761 | * block size = r128600 ----- r128755 -----
|
---|
762 | * reads reads writes
|
---|
763 | * 4096 KB = 2254 MB/s 4953 MB/s 3668 MB/s
|
---|
764 | * 2048 KB = 2368 MB/s 4908 MB/s 3541 MB/s
|
---|
765 | * 1024 KB = 2208 MB/s 4011 MB/s 3291 MB/s
|
---|
766 | * 512 KB = 1908 MB/s 3399 MB/s 2721 MB/s
|
---|
767 | * 256 KB = 1625 MB/s 2679 MB/s 2251 MB/s
|
---|
768 | * 128 KB = 1413 MB/s 1967 MB/s 1684 MB/s
|
---|
769 | * 64 KB = 1152 MB/s 1409 MB/s 1265 MB/s
|
---|
770 | * 32 KB = 726 MB/s 815 MB/s 783 MB/s
|
---|
771 | * 16 KB = 683 MB/s 475 MB/s
|
---|
772 | * 8 KB = 294 MB/s 286 MB/s
|
---|
773 | * 4 KB = 145 MB/s 156 MB/s 149 MB/s
|
---|
774 | *
|
---|
775 | */
|
---|
776 | if (S_ISREG(kstat->mode))
|
---|
777 | kstat->blksize = _1M;
|
---|
778 | else if (S_ISDIR(kstat->mode))
|
---|
779 | /** @todo this may need more tuning after we rewrite the directory handling. */
|
---|
780 | kstat->blksize = _16K;
|
---|
781 | }
|
---|
782 | return rc;
|
---|
783 | }
|
---|
784 | #endif /* >= 2.5.18 */
|
---|
785 |
|
---|
786 |
|
---|
787 | /**
|
---|
788 | * Modify inode attributes.
|
---|
789 | */
|
---|
790 | int vbsf_inode_setattr(struct dentry *dentry, struct iattr *iattr)
|
---|
791 | {
|
---|
792 | struct inode *pInode = dentry->d_inode;
|
---|
793 | struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(pInode->i_sb);
|
---|
794 | struct vbsf_inode_info *sf_i = VBSF_GET_INODE_INFO(pInode);
|
---|
795 | int vrc;
|
---|
796 | int rc;
|
---|
797 |
|
---|
798 | SFLOGFLOW(("vbsf_inode_setattr: dentry=%p inode=%p ia_valid=%#x %s\n",
|
---|
799 | dentry, pInode, iattr->ia_valid, sf_i ? sf_i->path->String.ach : NULL));
|
---|
800 | AssertReturn(sf_i, -EINVAL);
|
---|
801 |
|
---|
802 | /*
|
---|
803 | * Do minimal attribute permission checks. We set ATTR_FORCE since we cannot
|
---|
804 | * preserve ownership and such and would end up with EPERM here more often than
|
---|
805 | * we would like. For instance it would cause 'cp' to complain about EPERM
|
---|
806 | * from futimes() when asked to preserve times, see ticketref:18569.
|
---|
807 | */
|
---|
808 | iattr->ia_valid |= ATTR_FORCE;
|
---|
809 | #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 39) && LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)) || LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)
|
---|
810 | rc = setattr_prepare(dentry, iattr);
|
---|
811 | #else
|
---|
812 | rc = inode_change_ok(pInode, iattr);
|
---|
813 | #endif
|
---|
814 | if (rc == 0) {
|
---|
815 | /*
|
---|
816 | * Don't modify MTIME and CTIME for open(O_TRUNC) and ftruncate, those
|
---|
817 | * operations will set those timestamps automatically. Saves a host call.
|
---|
818 | */
|
---|
819 | unsigned fAttrs = iattr->ia_valid;
|
---|
820 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 15)
|
---|
821 | fAttrs &= ~ATTR_FILE;
|
---|
822 | #endif
|
---|
823 | if ( fAttrs == (ATTR_SIZE | ATTR_MTIME | ATTR_CTIME)
|
---|
824 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
|
---|
825 | || (fAttrs & (ATTR_OPEN | ATTR_SIZE)) == (ATTR_OPEN | ATTR_SIZE)
|
---|
826 | #endif
|
---|
827 | )
|
---|
828 | fAttrs &= ~(ATTR_MTIME | ATTR_CTIME);
|
---|
829 |
|
---|
830 | /*
|
---|
831 | * We only implement a handful of attributes, so ignore any attempts
|
---|
832 | * at setting bits we don't support.
|
---|
833 | */
|
---|
834 | if (fAttrs & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME | ATTR_CTIME | ATTR_SIZE)) {
|
---|
835 | /*
|
---|
836 | * Try find a handle which allows us to modify the attributes, otherwise
|
---|
837 | * open the file/dir/whatever.
|
---|
838 | */
|
---|
839 | union SetAttrReqs
|
---|
840 | {
|
---|
841 | VBOXSFCREATEREQ Create;
|
---|
842 | VBOXSFOBJINFOREQ Info;
|
---|
843 | VBOXSFSETFILESIZEREQ SetSize;
|
---|
844 | VBOXSFCLOSEREQ Close;
|
---|
845 | } *pReq;
|
---|
846 | size_t cbReq;
|
---|
847 | SHFLHANDLE hHostFile;
|
---|
848 | /** @todo ATTR_FILE (2.6.15+) could be helpful here if we like. */
|
---|
849 | struct vbsf_handle *pHandle = fAttrs & ATTR_SIZE
|
---|
850 | ? vbsf_handle_find(sf_i, VBSF_HANDLE_F_WRITE, 0)
|
---|
851 | : vbsf_handle_find(sf_i, 0, 0);
|
---|
852 | if (pHandle) {
|
---|
853 | hHostFile = pHandle->hHost;
|
---|
854 | cbReq = RT_MAX(sizeof(VBOXSFOBJINFOREQ), sizeof(VBOXSFSETFILESIZEREQ));
|
---|
855 | pReq = (union SetAttrReqs *)VbglR0PhysHeapAlloc(cbReq);
|
---|
856 | if (pReq) {
|
---|
857 | /* likely */
|
---|
858 | } else
|
---|
859 | rc = -ENOMEM;
|
---|
860 | } else {
|
---|
861 | hHostFile = SHFL_HANDLE_NIL;
|
---|
862 | cbReq = RT_MAX(sizeof(pReq->Info), sizeof(pReq->Create) + SHFLSTRING_HEADER_SIZE + sf_i->path->u16Size);
|
---|
863 | pReq = (union SetAttrReqs *)VbglR0PhysHeapAlloc(cbReq);
|
---|
864 | if (pReq) {
|
---|
865 | RT_ZERO(pReq->Create.CreateParms);
|
---|
866 | pReq->Create.CreateParms.Handle = SHFL_HANDLE_NIL;
|
---|
867 | pReq->Create.CreateParms.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
|
---|
868 | | SHFL_CF_ACT_FAIL_IF_NEW
|
---|
869 | | SHFL_CF_ACCESS_ATTR_WRITE;
|
---|
870 | if (fAttrs & ATTR_SIZE)
|
---|
871 | pReq->Create.CreateParms.CreateFlags |= SHFL_CF_ACCESS_WRITE;
|
---|
872 | memcpy(&pReq->Create.StrPath, sf_i->path, SHFLSTRING_HEADER_SIZE + sf_i->path->u16Size);
|
---|
873 | vrc = VbglR0SfHostReqCreate(pSuperInfo->map.root, &pReq->Create);
|
---|
874 | if (RT_SUCCESS(vrc)) {
|
---|
875 | if (pReq->Create.CreateParms.Result == SHFL_FILE_EXISTS) {
|
---|
876 | hHostFile = pReq->Create.CreateParms.Handle;
|
---|
877 | Assert(hHostFile != SHFL_HANDLE_NIL);
|
---|
878 | vbsf_dentry_chain_increase_ttl(dentry);
|
---|
879 | } else {
|
---|
880 | LogFunc(("file %s does not exist\n", sf_i->path->String.utf8));
|
---|
881 | vbsf_dentry_invalidate_ttl(dentry);
|
---|
882 | sf_i->force_restat = true;
|
---|
883 | rc = -ENOENT;
|
---|
884 | }
|
---|
885 | } else {
|
---|
886 | rc = -RTErrConvertToErrno(vrc);
|
---|
887 | LogFunc(("VbglR0SfCreate(%s) failed vrc=%Rrc rc=%d\n", sf_i->path->String.ach, vrc, rc));
|
---|
888 | }
|
---|
889 | } else
|
---|
890 | rc = -ENOMEM;
|
---|
891 | }
|
---|
892 | if (rc == 0) {
|
---|
893 | /*
|
---|
894 | * Set mode and/or timestamps.
|
---|
895 | */
|
---|
896 | if (fAttrs & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME | ATTR_CTIME)) {
|
---|
897 | /* Fill in the attributes. Start by setting all to zero
|
---|
898 | since the host will ignore zeroed fields. */
|
---|
899 | RT_ZERO(pReq->Info.ObjInfo);
|
---|
900 |
|
---|
901 | if (fAttrs & ATTR_MODE) {
|
---|
902 | pReq->Info.ObjInfo.Attr.fMode = sf_access_permissions_to_vbox(iattr->ia_mode);
|
---|
903 | if (iattr->ia_mode & S_IFDIR)
|
---|
904 | pReq->Info.ObjInfo.Attr.fMode |= RTFS_TYPE_DIRECTORY;
|
---|
905 | else if (iattr->ia_mode & S_IFLNK)
|
---|
906 | pReq->Info.ObjInfo.Attr.fMode |= RTFS_TYPE_SYMLINK;
|
---|
907 | else
|
---|
908 | pReq->Info.ObjInfo.Attr.fMode |= RTFS_TYPE_FILE;
|
---|
909 | }
|
---|
910 | if (fAttrs & ATTR_ATIME)
|
---|
911 | vbsf_time_to_vbox(&pReq->Info.ObjInfo.AccessTime, &iattr->ia_atime);
|
---|
912 | if (fAttrs & ATTR_MTIME)
|
---|
913 | vbsf_time_to_vbox(&pReq->Info.ObjInfo.ModificationTime, &iattr->ia_mtime);
|
---|
914 | if (fAttrs & ATTR_CTIME)
|
---|
915 | vbsf_time_to_vbox(&pReq->Info.ObjInfo.ChangeTime, &iattr->ia_ctime);
|
---|
916 |
|
---|
917 | /* Make the change. */
|
---|
918 | vrc = VbglR0SfHostReqSetObjInfo(pSuperInfo->map.root, &pReq->Info, hHostFile);
|
---|
919 | if (RT_SUCCESS(vrc)) {
|
---|
920 | vbsf_update_inode(pInode, sf_i, &pReq->Info.ObjInfo, pSuperInfo, true /*fLocked*/, fAttrs);
|
---|
921 | } else {
|
---|
922 | rc = -RTErrConvertToErrno(vrc);
|
---|
923 | LogFunc(("VbglR0SfHostReqSetObjInfo(%s) failed vrc=%Rrc rc=%d\n", sf_i->path->String.ach, vrc, rc));
|
---|
924 | }
|
---|
925 | }
|
---|
926 |
|
---|
927 | /*
|
---|
928 | * Change the file size.
|
---|
929 | * Note! Old API is more convenient here as it gives us up to date
|
---|
930 | * inode info back.
|
---|
931 | */
|
---|
932 | if ((fAttrs & ATTR_SIZE) && rc == 0) {
|
---|
933 | /*vrc = VbglR0SfHostReqSetFileSize(pSuperInfo->map.root, &pReq->SetSize, hHostFile, iattr->ia_size);
|
---|
934 | if (RT_SUCCESS(vrc)) {
|
---|
935 | i_size_write(pInode, iattr->ia_size);
|
---|
936 | } else if (vrc == VERR_NOT_IMPLEMENTED)*/ {
|
---|
937 | /* Fallback for pre 6.0 hosts: */
|
---|
938 | RT_ZERO(pReq->Info.ObjInfo);
|
---|
939 | pReq->Info.ObjInfo.cbObject = iattr->ia_size;
|
---|
940 | vrc = VbglR0SfHostReqSetFileSizeOld(pSuperInfo->map.root, &pReq->Info, hHostFile);
|
---|
941 | if (RT_SUCCESS(vrc))
|
---|
942 | vbsf_update_inode(pInode, sf_i, &pReq->Info.ObjInfo, pSuperInfo, true /*fLocked*/, fAttrs);
|
---|
943 | }
|
---|
944 | if (RT_SUCCESS(vrc)) {
|
---|
945 | /** @todo there is potentially more to be done here if there are mappings of
|
---|
946 | * the lovely file. */
|
---|
947 | } else {
|
---|
948 | rc = -RTErrConvertToErrno(vrc);
|
---|
949 | LogFunc(("VbglR0SfHostReqSetFileSize(%s, %#llx) failed vrc=%Rrc rc=%d\n",
|
---|
950 | sf_i->path->String.ach, (unsigned long long)iattr->ia_size, vrc, rc));
|
---|
951 | }
|
---|
952 | }
|
---|
953 |
|
---|
954 | /*
|
---|
955 | * Clean up.
|
---|
956 | */
|
---|
957 | if (!pHandle) {
|
---|
958 | vrc = VbglR0SfHostReqClose(pSuperInfo->map.root, &pReq->Close, hHostFile);
|
---|
959 | if (RT_FAILURE(vrc))
|
---|
960 | LogFunc(("VbglR0SfHostReqClose(%s [%#llx]) failed vrc=%Rrc\n", sf_i->path->String.utf8, hHostFile, vrc));
|
---|
961 | }
|
---|
962 | }
|
---|
963 | if (pReq)
|
---|
964 | VbglR0PhysHeapFree(pReq);
|
---|
965 | if (pHandle)
|
---|
966 | vbsf_handle_release(pHandle, pSuperInfo, "vbsf_inode_setattr");
|
---|
967 | } else
|
---|
968 | SFLOGFLOW(("vbsf_inode_setattr: Nothing to do here: %#x (was %#x).\n", fAttrs, iattr->ia_valid));
|
---|
969 | }
|
---|
970 | return rc;
|
---|
971 | }
|
---|
972 |
|
---|
973 |
|
---|
974 | static int vbsf_make_path(const char *caller, struct vbsf_inode_info *sf_i,
|
---|
975 | const char *d_name, size_t d_len, SHFLSTRING **result)
|
---|
976 | {
|
---|
977 | size_t path_len, shflstring_len;
|
---|
978 | SHFLSTRING *tmp;
|
---|
979 | uint16_t p_len;
|
---|
980 | uint8_t *p_name;
|
---|
981 | int fRoot = 0;
|
---|
982 |
|
---|
983 | TRACE();
|
---|
984 | p_len = sf_i->path->u16Length;
|
---|
985 | p_name = sf_i->path->String.utf8;
|
---|
986 |
|
---|
987 | if (p_len == 1 && *p_name == '/') {
|
---|
988 | path_len = d_len + 1;
|
---|
989 | fRoot = 1;
|
---|
990 | } else {
|
---|
991 | /* lengths of constituents plus terminating zero plus slash */
|
---|
992 | path_len = p_len + d_len + 2;
|
---|
993 | if (path_len > 0xffff) {
|
---|
994 | LogFunc(("path too long. caller=%s, path_len=%zu\n",
|
---|
995 | caller, path_len));
|
---|
996 | return -ENAMETOOLONG;
|
---|
997 | }
|
---|
998 | }
|
---|
999 |
|
---|
1000 | shflstring_len = offsetof(SHFLSTRING, String.utf8) + path_len;
|
---|
1001 | tmp = kmalloc(shflstring_len, GFP_KERNEL);
|
---|
1002 | if (!tmp) {
|
---|
1003 | LogRelFunc(("kmalloc failed, caller=%s\n", caller));
|
---|
1004 | return -ENOMEM;
|
---|
1005 | }
|
---|
1006 | tmp->u16Length = path_len - 1;
|
---|
1007 | tmp->u16Size = path_len;
|
---|
1008 |
|
---|
1009 | if (fRoot)
|
---|
1010 | memcpy(&tmp->String.utf8[0], d_name, d_len + 1);
|
---|
1011 | else {
|
---|
1012 | memcpy(&tmp->String.utf8[0], p_name, p_len);
|
---|
1013 | tmp->String.utf8[p_len] = '/';
|
---|
1014 | memcpy(&tmp->String.utf8[p_len + 1], d_name, d_len);
|
---|
1015 | tmp->String.utf8[p_len + 1 + d_len] = '\0';
|
---|
1016 | }
|
---|
1017 |
|
---|
1018 | *result = tmp;
|
---|
1019 | return 0;
|
---|
1020 | }
|
---|
1021 |
|
---|
1022 |
|
---|
1023 | /**
|
---|
1024 | * [dentry] contains string encoded in coding system that corresponds
|
---|
1025 | * to [pSuperInfo]->nls, we must convert it to UTF8 here and pass down to
|
---|
1026 | * [vbsf_make_path] which will allocate SHFLSTRING and fill it in
|
---|
1027 | */
|
---|
1028 | int vbsf_path_from_dentry(struct vbsf_super_info *pSuperInfo, struct vbsf_inode_info *sf_i, struct dentry *dentry,
|
---|
1029 | SHFLSTRING **result, const char *caller)
|
---|
1030 | {
|
---|
1031 | int err;
|
---|
1032 | const char *d_name;
|
---|
1033 | size_t d_len;
|
---|
1034 | const char *name;
|
---|
1035 | size_t len = 0;
|
---|
1036 |
|
---|
1037 | TRACE();
|
---|
1038 | d_name = dentry->d_name.name;
|
---|
1039 | d_len = dentry->d_name.len;
|
---|
1040 |
|
---|
1041 | if (pSuperInfo->nls) {
|
---|
1042 | size_t in_len, i, out_bound_len;
|
---|
1043 | const char *in;
|
---|
1044 | char *out;
|
---|
1045 |
|
---|
1046 | in = d_name;
|
---|
1047 | in_len = d_len;
|
---|
1048 |
|
---|
1049 | out_bound_len = PATH_MAX;
|
---|
1050 | out = kmalloc(out_bound_len, GFP_KERNEL);
|
---|
1051 | name = out;
|
---|
1052 |
|
---|
1053 | for (i = 0; i < d_len; ++i) {
|
---|
1054 | /* We renamed the linux kernel wchar_t type to linux_wchar_t in
|
---|
1055 | the-linux-kernel.h, as it conflicts with the C++ type of that name. */
|
---|
1056 | linux_wchar_t uni;
|
---|
1057 | int nb;
|
---|
1058 |
|
---|
1059 | nb = pSuperInfo->nls->char2uni(in, in_len, &uni);
|
---|
1060 | if (nb < 0) {
|
---|
1061 | LogFunc(("nls->char2uni failed %x %d\n",
|
---|
1062 | *in, in_len));
|
---|
1063 | err = -EINVAL;
|
---|
1064 | goto fail1;
|
---|
1065 | }
|
---|
1066 | in_len -= nb;
|
---|
1067 | in += nb;
|
---|
1068 |
|
---|
1069 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
|
---|
1070 | nb = utf32_to_utf8(uni, out, out_bound_len);
|
---|
1071 | #else
|
---|
1072 | nb = utf8_wctomb(out, uni, out_bound_len);
|
---|
1073 | #endif
|
---|
1074 | if (nb < 0) {
|
---|
1075 | LogFunc(("nls->uni2char failed %x %d\n",
|
---|
1076 | uni, out_bound_len));
|
---|
1077 | err = -EINVAL;
|
---|
1078 | goto fail1;
|
---|
1079 | }
|
---|
1080 | out_bound_len -= nb;
|
---|
1081 | out += nb;
|
---|
1082 | len += nb;
|
---|
1083 | }
|
---|
1084 | if (len >= PATH_MAX - 1) {
|
---|
1085 | err = -ENAMETOOLONG;
|
---|
1086 | goto fail1;
|
---|
1087 | }
|
---|
1088 |
|
---|
1089 | LogFunc(("result(%d) = %.*s\n", len, len, name));
|
---|
1090 | *out = 0;
|
---|
1091 | } else {
|
---|
1092 | name = d_name;
|
---|
1093 | len = d_len;
|
---|
1094 | }
|
---|
1095 |
|
---|
1096 | err = vbsf_make_path(caller, sf_i, name, len, result);
|
---|
1097 | if (name != d_name)
|
---|
1098 | kfree(name);
|
---|
1099 |
|
---|
1100 | return err;
|
---|
1101 |
|
---|
1102 | fail1:
|
---|
1103 | kfree(name);
|
---|
1104 | return err;
|
---|
1105 | }
|
---|
1106 |
|
---|
1107 |
|
---|
1108 | /**
|
---|
1109 | * This is called during name resolution/lookup to check if the @a dentry in the
|
---|
1110 | * cache is still valid. The actual validation is job is handled by
|
---|
1111 | * vbsf_inode_revalidate_worker().
|
---|
1112 | *
|
---|
1113 | * @note Caller holds no relevant locks, just a dentry reference.
|
---|
1114 | */
|
---|
1115 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
|
---|
1116 | static int vbsf_dentry_revalidate(struct dentry *dentry, unsigned flags)
|
---|
1117 | #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
|
---|
1118 | static int vbsf_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
|
---|
1119 | #else
|
---|
1120 | static int vbsf_dentry_revalidate(struct dentry *dentry, int flags)
|
---|
1121 | #endif
|
---|
1122 | {
|
---|
1123 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && LINUX_VERSION_CODE < KERNEL_VERSION(3, 6, 0)
|
---|
1124 | int const flags = nd ? nd->flags : 0;
|
---|
1125 | #endif
|
---|
1126 |
|
---|
1127 | int rc;
|
---|
1128 |
|
---|
1129 | Assert(dentry);
|
---|
1130 | SFLOGFLOW(("vbsf_dentry_revalidate: %p %#x %s\n", dentry, flags,
|
---|
1131 | dentry->d_inode ? VBSF_GET_INODE_INFO(dentry->d_inode)->path->String.ach : "<negative>"));
|
---|
1132 |
|
---|
1133 | /*
|
---|
1134 | * See Documentation/filesystems/vfs.txt why we skip LOOKUP_RCU.
|
---|
1135 | *
|
---|
1136 | * Also recommended: https://lwn.net/Articles/649115/
|
---|
1137 | * https://lwn.net/Articles/649729/
|
---|
1138 | * https://lwn.net/Articles/650786/
|
---|
1139 | *
|
---|
1140 | */
|
---|
1141 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
|
---|
1142 | if (flags & LOOKUP_RCU) {
|
---|
1143 | rc = -ECHILD;
|
---|
1144 | SFLOGFLOW(("vbsf_dentry_revalidate: RCU -> -ECHILD\n"));
|
---|
1145 | } else
|
---|
1146 | #endif
|
---|
1147 | {
|
---|
1148 | /*
|
---|
1149 | * Do we have an inode or not? If not it's probably a negative cache
|
---|
1150 | * entry, otherwise most likely a positive one.
|
---|
1151 | */
|
---|
1152 | struct inode *pInode = dentry->d_inode;
|
---|
1153 | if (pInode) {
|
---|
1154 | /*
|
---|
1155 | * Positive entry.
|
---|
1156 | *
|
---|
1157 | * Note! We're more aggressive here than other remote file systems,
|
---|
1158 | * current (4.19) CIFS will for instance revalidate the inode
|
---|
1159 | * and ignore the dentry timestamp for positive entries.
|
---|
1160 | */
|
---|
1161 | unsigned long const cJiffiesAge = jiffies - vbsf_dentry_get_update_jiffies(dentry);
|
---|
1162 | struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(dentry->d_sb);
|
---|
1163 | if (cJiffiesAge < pSuperInfo->cJiffiesDirCacheTTL) {
|
---|
1164 | SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, pSuperInfo->cJiffiesDirCacheTTL));
|
---|
1165 | rc = 1;
|
---|
1166 | } else if (!vbsf_inode_revalidate_worker(dentry, true /*fForced*/, false /*fInodeLocked*/)) {
|
---|
1167 | vbsf_dentry_set_update_jiffies(dentry, jiffies);
|
---|
1168 | SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 1\n", cJiffiesAge, pSuperInfo->cJiffiesDirCacheTTL));
|
---|
1169 | rc = 1;
|
---|
1170 | } else {
|
---|
1171 | SFLOGFLOW(("vbsf_dentry_revalidate: age: %lu vs. TTL %lu -> reval -> 0\n", cJiffiesAge, pSuperInfo->cJiffiesDirCacheTTL));
|
---|
1172 | rc = 0;
|
---|
1173 | }
|
---|
1174 | } else {
|
---|
1175 | /*
|
---|
1176 | * Negative entry.
|
---|
1177 | *
|
---|
1178 | * Invalidate dentries for open and renames here as we'll revalidate
|
---|
1179 | * these when taking the actual action (also good for case preservation
|
---|
1180 | * if we do case-insensitive mounts against windows + mac hosts at some
|
---|
1181 | * later point).
|
---|
1182 | */
|
---|
1183 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
|
---|
1184 | if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
|
---|
1185 | #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 75)
|
---|
1186 | if (flags & LOOKUP_CREATE)
|
---|
1187 | #else
|
---|
1188 | if (0)
|
---|
1189 | #endif
|
---|
1190 | {
|
---|
1191 | SFLOGFLOW(("vbsf_dentry_revalidate: negative: create or rename target -> 0\n"));
|
---|
1192 | rc = 0;
|
---|
1193 | } else {
|
---|
1194 | /* Can we skip revalidation based on TTL? */
|
---|
1195 | unsigned long const cJiffiesAge = vbsf_dentry_get_update_jiffies(dentry) - jiffies;
|
---|
1196 | struct vbsf_super_info *pSuperInfo = VBSF_GET_SUPER_INFO(dentry->d_sb);
|
---|
1197 | if (cJiffiesAge < pSuperInfo->cJiffiesDirCacheTTL) {
|
---|
1198 | SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 1\n", cJiffiesAge, pSuperInfo->cJiffiesDirCacheTTL));
|
---|
1199 | rc = 1;
|
---|
1200 | } else {
|
---|
1201 | /* We could revalidate it here, but we could instead just
|
---|
1202 | have the caller kick it out. */
|
---|
1203 | /** @todo stat the direntry and see if it exists now. */
|
---|
1204 | SFLOGFLOW(("vbsf_dentry_revalidate: negative: age: %lu vs. TTL %lu -> 0\n", cJiffiesAge, pSuperInfo->cJiffiesDirCacheTTL));
|
---|
1205 | rc = 0;
|
---|
1206 | }
|
---|
1207 | }
|
---|
1208 | }
|
---|
1209 | }
|
---|
1210 | return rc;
|
---|
1211 | }
|
---|
1212 |
|
---|
1213 | #ifdef SFLOG_ENABLED
|
---|
1214 |
|
---|
1215 | /** For logging purposes only. */
|
---|
1216 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 38)
|
---|
1217 | static int vbsf_dentry_delete(const struct dentry *pDirEntry)
|
---|
1218 | # else
|
---|
1219 | static int vbsf_dentry_delete(struct dentry *pDirEntry)
|
---|
1220 | # endif
|
---|
1221 | {
|
---|
1222 | SFLOGFLOW(("vbsf_dentry_delete: %p\n", pDirEntry));
|
---|
1223 | return 0;
|
---|
1224 | }
|
---|
1225 |
|
---|
1226 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
|
---|
1227 | /** For logging purposes only. */
|
---|
1228 | static int vbsf_dentry_init(struct dentry *pDirEntry)
|
---|
1229 | {
|
---|
1230 | SFLOGFLOW(("vbsf_dentry_init: %p\n", pDirEntry));
|
---|
1231 | return 0;
|
---|
1232 | }
|
---|
1233 | # endif
|
---|
1234 |
|
---|
1235 | #endif /* SFLOG_ENABLED */
|
---|
1236 |
|
---|
1237 | /**
|
---|
1238 | * Directory entry operations.
|
---|
1239 | *
|
---|
1240 | * Since 2.6.38 this is used via the super_block::s_d_op member.
|
---|
1241 | */
|
---|
1242 | struct dentry_operations vbsf_dentry_ops = {
|
---|
1243 | .d_revalidate = vbsf_dentry_revalidate,
|
---|
1244 | #ifdef SFLOG_ENABLED
|
---|
1245 | .d_delete = vbsf_dentry_delete,
|
---|
1246 | # if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
|
---|
1247 | .d_init = vbsf_dentry_init,
|
---|
1248 | # endif
|
---|
1249 | #endif
|
---|
1250 | };
|
---|
1251 |
|
---|