?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.8-rc8
[linux/fpc-iii.git] / fs / orangefs / orangefs-utils.c
blobd13c7291fd054059a52e47f916f5913f7ed075aa
1 /*
2 * (C) 2001 Clemson University and The University of Chicago
3 *
4 * See COPYING in top-level directory.
5 */
6 #include "protocol.h"
7 #include "orangefs-kernel.h"
8 #include "orangefs-dev-proto.h"
9 #include "orangefs-bufmap.h"
10
11 __s32 fsid_of_op(struct orangefs_kernel_op_s *op)
12 {
13 __s32 fsid = ORANGEFS_FS_ID_NULL;
14
15 if (op) {
16 switch (op->upcall.type) {
17 case ORANGEFS_VFS_OP_FILE_IO:
18 fsid = op->upcall.req.io.refn.fs_id;
19 break;
20 case ORANGEFS_VFS_OP_LOOKUP:
21 fsid = op->upcall.req.lookup.parent_refn.fs_id;
22 break;
23 case ORANGEFS_VFS_OP_CREATE:
24 fsid = op->upcall.req.create.parent_refn.fs_id;
25 break;
26 case ORANGEFS_VFS_OP_GETATTR:
27 fsid = op->upcall.req.getattr.refn.fs_id;
28 break;
29 case ORANGEFS_VFS_OP_REMOVE:
30 fsid = op->upcall.req.remove.parent_refn.fs_id;
31 break;
32 case ORANGEFS_VFS_OP_MKDIR:
33 fsid = op->upcall.req.mkdir.parent_refn.fs_id;
34 break;
35 case ORANGEFS_VFS_OP_READDIR:
36 fsid = op->upcall.req.readdir.refn.fs_id;
37 break;
38 case ORANGEFS_VFS_OP_SETATTR:
39 fsid = op->upcall.req.setattr.refn.fs_id;
40 break;
41 case ORANGEFS_VFS_OP_SYMLINK:
42 fsid = op->upcall.req.sym.parent_refn.fs_id;
43 break;
44 case ORANGEFS_VFS_OP_RENAME:
45 fsid = op->upcall.req.rename.old_parent_refn.fs_id;
46 break;
47 case ORANGEFS_VFS_OP_STATFS:
48 fsid = op->upcall.req.statfs.fs_id;
49 break;
50 case ORANGEFS_VFS_OP_TRUNCATE:
51 fsid = op->upcall.req.truncate.refn.fs_id;
52 break;
53 case ORANGEFS_VFS_OP_MMAP_RA_FLUSH:
54 fsid = op->upcall.req.ra_cache_flush.refn.fs_id;
55 break;
56 case ORANGEFS_VFS_OP_FS_UMOUNT:
57 fsid = op->upcall.req.fs_umount.fs_id;
58 break;
59 case ORANGEFS_VFS_OP_GETXATTR:
60 fsid = op->upcall.req.getxattr.refn.fs_id;
61 break;
62 case ORANGEFS_VFS_OP_SETXATTR:
63 fsid = op->upcall.req.setxattr.refn.fs_id;
64 break;
65 case ORANGEFS_VFS_OP_LISTXATTR:
66 fsid = op->upcall.req.listxattr.refn.fs_id;
67 break;
68 case ORANGEFS_VFS_OP_REMOVEXATTR:
69 fsid = op->upcall.req.removexattr.refn.fs_id;
70 break;
71 case ORANGEFS_VFS_OP_FSYNC:
72 fsid = op->upcall.req.fsync.refn.fs_id;
73 break;
74 default:
75 break;
76 }
77 }
78 return fsid;
79 }
80
81 static int orangefs_inode_flags(struct ORANGEFS_sys_attr_s *attrs)
82 {
83 int flags = 0;
84 if (attrs->flags & ORANGEFS_IMMUTABLE_FL)
85 flags |= S_IMMUTABLE;
86 else
87 flags &= ~S_IMMUTABLE;
88 if (attrs->flags & ORANGEFS_APPEND_FL)
89 flags |= S_APPEND;
90 else
91 flags &= ~S_APPEND;
92 if (attrs->flags & ORANGEFS_NOATIME_FL)
93 flags |= S_NOATIME;
94 else
95 flags &= ~S_NOATIME;
96 return flags;
97 }
98
99 static int orangefs_inode_perms(struct ORANGEFS_sys_attr_s *attrs)
100 {
101 int perm_mode = 0;
102
103 if (attrs->perms & ORANGEFS_O_EXECUTE)
104 perm_mode |= S_IXOTH;
105 if (attrs->perms & ORANGEFS_O_WRITE)
106 perm_mode |= S_IWOTH;
107 if (attrs->perms & ORANGEFS_O_READ)
108 perm_mode |= S_IROTH;
109
110 if (attrs->perms & ORANGEFS_G_EXECUTE)
111 perm_mode |= S_IXGRP;
112 if (attrs->perms & ORANGEFS_G_WRITE)
113 perm_mode |= S_IWGRP;
114 if (attrs->perms & ORANGEFS_G_READ)
115 perm_mode |= S_IRGRP;
116
117 if (attrs->perms & ORANGEFS_U_EXECUTE)
118 perm_mode |= S_IXUSR;
119 if (attrs->perms & ORANGEFS_U_WRITE)
120 perm_mode |= S_IWUSR;
121 if (attrs->perms & ORANGEFS_U_READ)
122 perm_mode |= S_IRUSR;
123
124 if (attrs->perms & ORANGEFS_G_SGID)
125 perm_mode |= S_ISGID;
126 if (attrs->perms & ORANGEFS_U_SUID)
127 perm_mode |= S_ISUID;
128
129 return perm_mode;
130 }
131
132 /*
133 * NOTE: in kernel land, we never use the sys_attr->link_target for
134 * anything, so don't bother copying it into the sys_attr object here.
135 */
136 static inline int copy_attributes_from_inode(struct inode *inode,
137 struct ORANGEFS_sys_attr_s *attrs,
138 struct iattr *iattr)
139 {
140 umode_t tmp_mode;
141
142 if (!iattr || !inode || !attrs) {
143 gossip_err("NULL iattr (%p), inode (%p), attrs (%p) "
144 "in copy_attributes_from_inode!\n",
145 iattr,
146 inode,
147 attrs);
148 return -EINVAL;
149 }
150 /*
151 * We need to be careful to only copy the attributes out of the
152 * iattr object that we know are valid.
153 */
154 attrs->mask = 0;
155 if (iattr->ia_valid & ATTR_UID) {
156 attrs->owner = from_kuid(&init_user_ns, iattr->ia_uid);
157 attrs->mask |= ORANGEFS_ATTR_SYS_UID;
158 gossip_debug(GOSSIP_UTILS_DEBUG, "(UID) %d\n", attrs->owner);
159 }
160 if (iattr->ia_valid & ATTR_GID) {
161 attrs->group = from_kgid(&init_user_ns, iattr->ia_gid);
162 attrs->mask |= ORANGEFS_ATTR_SYS_GID;
163 gossip_debug(GOSSIP_UTILS_DEBUG, "(GID) %d\n", attrs->group);
164 }
165
166 if (iattr->ia_valid & ATTR_ATIME) {
167 attrs->mask |= ORANGEFS_ATTR_SYS_ATIME;
168 if (iattr->ia_valid & ATTR_ATIME_SET) {
169 attrs->atime = (time64_t)iattr->ia_atime.tv_sec;
170 attrs->mask |= ORANGEFS_ATTR_SYS_ATIME_SET;
171 }
172 }
173 if (iattr->ia_valid & ATTR_MTIME) {
174 attrs->mask |= ORANGEFS_ATTR_SYS_MTIME;
175 if (iattr->ia_valid & ATTR_MTIME_SET) {
176 attrs->mtime = (time64_t)iattr->ia_mtime.tv_sec;
177 attrs->mask |= ORANGEFS_ATTR_SYS_MTIME_SET;
178 }
179 }
180 if (iattr->ia_valid & ATTR_CTIME)
181 attrs->mask |= ORANGEFS_ATTR_SYS_CTIME;
182
183 /*
184 * ORANGEFS cannot set size with a setattr operation. Probably not likely
185 * to be requested through the VFS, but just in case, don't worry about
186 * ATTR_SIZE
187 */
188
189 if (iattr->ia_valid & ATTR_MODE) {
190 tmp_mode = iattr->ia_mode;
191 if (tmp_mode & (S_ISVTX)) {
192 if (is_root_handle(inode)) {
193 /*
194 * allow sticky bit to be set on root (since
195 * it shows up that way by default anyhow),
196 * but don't show it to the server
197 */
198 tmp_mode -= S_ISVTX;
199 } else {
200 gossip_debug(GOSSIP_UTILS_DEBUG,
201 "User attempted to set sticky bit on non-root directory; returning EINVAL.\n");
202 return -EINVAL;
203 }
204 }
205
206 if (tmp_mode & (S_ISUID)) {
207 gossip_debug(GOSSIP_UTILS_DEBUG,
208 "Attempting to set setuid bit (not supported); returning EINVAL.\n");
209 return -EINVAL;
210 }
211
212 attrs->perms = ORANGEFS_util_translate_mode(tmp_mode);
213 attrs->mask |= ORANGEFS_ATTR_SYS_PERM;
214 }
215
216 return 0;
217 }
218
219 static int orangefs_inode_type(enum orangefs_ds_type objtype)
220 {
221 if (objtype == ORANGEFS_TYPE_METAFILE)
222 return S_IFREG;
223 else if (objtype == ORANGEFS_TYPE_DIRECTORY)
224 return S_IFDIR;
225 else if (objtype == ORANGEFS_TYPE_SYMLINK)
226 return S_IFLNK;
227 else
228 return -1;
229 }
230
231 static int orangefs_inode_is_stale(struct inode *inode, int new,
232 struct ORANGEFS_sys_attr_s *attrs, char *link_target)
233 {
234 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
235 int type = orangefs_inode_type(attrs->objtype);
236 if (!new) {
237 /*
238 * If the inode type or symlink target have changed then this
239 * inode is stale.
240 */
241 if (type == -1 || !(inode->i_mode & type)) {
242 orangefs_make_bad_inode(inode);
243 return 1;
244 }
245 if (type == S_IFLNK && strncmp(orangefs_inode->link_target,
246 link_target, ORANGEFS_NAME_MAX)) {
247 orangefs_make_bad_inode(inode);
248 return 1;
249 }
250 }
251 return 0;
252 }
253
254 int orangefs_inode_getattr(struct inode *inode, int new, int bypass)
255 {
256 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
257 struct orangefs_kernel_op_s *new_op;
258 loff_t inode_size, rounded_up_size;
259 int ret, type;
260
261 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__,
262 get_khandle_from_ino(inode));
263
264 if (!new && !bypass) {
265 if (time_before(jiffies, orangefs_inode->getattr_time))
266 return 0;
267 }
268
269 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
270 if (!new_op)
271 return -ENOMEM;
272 new_op->upcall.req.getattr.refn = orangefs_inode->refn;
273 new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_ALL_NOHINT;
274
275 ret = service_operation(new_op, __func__,
276 get_interruptible_flag(inode));
277 if (ret != 0)
278 goto out;
279
280 type = orangefs_inode_type(new_op->
281 downcall.resp.getattr.attributes.objtype);
282 ret = orangefs_inode_is_stale(inode, new,
283 &new_op->downcall.resp.getattr.attributes,
284 new_op->downcall.resp.getattr.link_target);
285 if (ret) {
286 ret = -ESTALE;
287 goto out;
288 }
289
290 switch (type) {
291 case S_IFREG:
292 inode->i_flags = orangefs_inode_flags(&new_op->
293 downcall.resp.getattr.attributes);
294 inode_size = (loff_t)new_op->
295 downcall.resp.getattr.attributes.size;
296 rounded_up_size =
297 (inode_size + (4096 - (inode_size % 4096)));
298 inode->i_size = inode_size;
299 orangefs_inode->blksize =
300 new_op->downcall.resp.getattr.attributes.blksize;
301 spin_lock(&inode->i_lock);
302 inode->i_bytes = inode_size;
303 inode->i_blocks =
304 (unsigned long)(rounded_up_size / 512);
305 spin_unlock(&inode->i_lock);
306 break;
307 case S_IFDIR:
308 inode->i_size = PAGE_SIZE;
309 orangefs_inode->blksize = (1 << inode->i_blkbits);
310 spin_lock(&inode->i_lock);
311 inode_set_bytes(inode, inode->i_size);
312 spin_unlock(&inode->i_lock);
313 set_nlink(inode, 1);
314 break;
315 case S_IFLNK:
316 if (new) {
317 inode->i_size = (loff_t)strlen(new_op->
318 downcall.resp.getattr.link_target);
319 orangefs_inode->blksize = (1 << inode->i_blkbits);
320 ret = strscpy(orangefs_inode->link_target,
321 new_op->downcall.resp.getattr.link_target,
322 ORANGEFS_NAME_MAX);
323 if (ret == -E2BIG) {
324 ret = -EIO;
325 goto out;
326 }
327 inode->i_link = orangefs_inode->link_target;
328 }
329 break;
330 }
331
332 inode->i_uid = make_kuid(&init_user_ns, new_op->
333 downcall.resp.getattr.attributes.owner);
334 inode->i_gid = make_kgid(&init_user_ns, new_op->
335 downcall.resp.getattr.attributes.group);
336 inode->i_atime.tv_sec = (time64_t)new_op->
337 downcall.resp.getattr.attributes.atime;
338 inode->i_mtime.tv_sec = (time64_t)new_op->
339 downcall.resp.getattr.attributes.mtime;
340 inode->i_ctime.tv_sec = (time64_t)new_op->
341 downcall.resp.getattr.attributes.ctime;
342 inode->i_atime.tv_nsec = 0;
343 inode->i_mtime.tv_nsec = 0;
344 inode->i_ctime.tv_nsec = 0;
345
346 /* special case: mark the root inode as sticky */
347 inode->i_mode = type | (is_root_handle(inode) ? S_ISVTX : 0) |
348 orangefs_inode_perms(&new_op->downcall.resp.getattr.attributes);
349
350 orangefs_inode->getattr_time = jiffies + getattr_timeout_msecs*HZ/1000;
351 ret = 0;
352 out:
353 op_release(new_op);
354 return ret;
355 }
356
357 int orangefs_inode_check_changed(struct inode *inode)
358 {
359 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
360 struct orangefs_kernel_op_s *new_op;
361 int ret;
362
363 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__,
364 get_khandle_from_ino(inode));
365
366 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
367 if (!new_op)
368 return -ENOMEM;
369 new_op->upcall.req.getattr.refn = orangefs_inode->refn;
370 new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_TYPE |
371 ORANGEFS_ATTR_SYS_LNK_TARGET;
372
373 ret = service_operation(new_op, __func__,
374 get_interruptible_flag(inode));
375 if (ret != 0)
376 goto out;
377
378 ret = orangefs_inode_is_stale(inode, 0,
379 &new_op->downcall.resp.getattr.attributes,
380 new_op->downcall.resp.getattr.link_target);
381 out:
382 op_release(new_op);
383 return ret;
384 }
385
386 /*
387 * issues a orangefs setattr request to make sure the new attribute values
388 * take effect if successful. returns 0 on success; -errno otherwise
389 */
390 int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr)
391 {
392 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
393 struct orangefs_kernel_op_s *new_op;
394 int ret;
395
396 new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR);
397 if (!new_op)
398 return -ENOMEM;
399
400 new_op->upcall.req.setattr.refn = orangefs_inode->refn;
401 ret = copy_attributes_from_inode(inode,
402 &new_op->upcall.req.setattr.attributes,
403 iattr);
404 if (ret >= 0) {
405 ret = service_operation(new_op, __func__,
406 get_interruptible_flag(inode));
407
408 gossip_debug(GOSSIP_UTILS_DEBUG,
409 "orangefs_inode_setattr: returning %d\n",
410 ret);
411 }
412
413 op_release(new_op);
414
415 /*
416 * successful setattr should clear the atime, mtime and
417 * ctime flags.
418 */
419 if (ret == 0) {
420 ClearAtimeFlag(orangefs_inode);
421 ClearMtimeFlag(orangefs_inode);
422 ClearCtimeFlag(orangefs_inode);
423 ClearModeFlag(orangefs_inode);
424 orangefs_inode->getattr_time = jiffies - 1;
425 }
426
427 return ret;
428 }
429
430 int orangefs_flush_inode(struct inode *inode)
431 {
432 /*
433 * If it is a dirty inode, this function gets called.
434 * Gather all the information that needs to be setattr'ed
435 * Right now, this will only be used for mode, atime, mtime
436 * and/or ctime.
437 */
438 struct iattr wbattr;
439 int ret;
440 int mtime_flag;
441 int ctime_flag;
442 int atime_flag;
443 int mode_flag;
444 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
445
446 memset(&wbattr, 0, sizeof(wbattr));
447
448 /*
449 * check inode flags up front, and clear them if they are set. This
450 * will prevent multiple processes from all trying to flush the same
451 * inode if they call close() simultaneously
452 */
453 mtime_flag = MtimeFlag(orangefs_inode);
454 ClearMtimeFlag(orangefs_inode);
455 ctime_flag = CtimeFlag(orangefs_inode);
456 ClearCtimeFlag(orangefs_inode);
457 atime_flag = AtimeFlag(orangefs_inode);
458 ClearAtimeFlag(orangefs_inode);
459 mode_flag = ModeFlag(orangefs_inode);
460 ClearModeFlag(orangefs_inode);
461
462 /* -- Lazy atime,mtime and ctime update --
463 * Note: all times are dictated by server in the new scheme
464 * and not by the clients
465 *
466 * Also mode updates are being handled now..
467 */
468
469 if (mtime_flag)
470 wbattr.ia_valid |= ATTR_MTIME;
471 if (ctime_flag)
472 wbattr.ia_valid |= ATTR_CTIME;
473 if (atime_flag)
474 wbattr.ia_valid |= ATTR_ATIME;
475
476 if (mode_flag) {
477 wbattr.ia_mode = inode->i_mode;
478 wbattr.ia_valid |= ATTR_MODE;
479 }
480
481 gossip_debug(GOSSIP_UTILS_DEBUG,
482 "*********** orangefs_flush_inode: %pU "
483 "(ia_valid %d)\n",
484 get_khandle_from_ino(inode),
485 wbattr.ia_valid);
486 if (wbattr.ia_valid == 0) {
487 gossip_debug(GOSSIP_UTILS_DEBUG,
488 "orangefs_flush_inode skipping setattr()\n");
489 return 0;
490 }
491
492 gossip_debug(GOSSIP_UTILS_DEBUG,
493 "orangefs_flush_inode (%pU) writing mode %o\n",
494 get_khandle_from_ino(inode),
495 inode->i_mode);
496
497 ret = orangefs_inode_setattr(inode, &wbattr);
498
499 return ret;
500 }
501
502 int orangefs_unmount_sb(struct super_block *sb)
503 {
504 int ret = -EINVAL;
505 struct orangefs_kernel_op_s *new_op = NULL;
506
507 gossip_debug(GOSSIP_UTILS_DEBUG,
508 "orangefs_unmount_sb called on sb %p\n",
509 sb);
510
511 new_op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT);
512 if (!new_op)
513 return -ENOMEM;
514 new_op->upcall.req.fs_umount.id = ORANGEFS_SB(sb)->id;
515 new_op->upcall.req.fs_umount.fs_id = ORANGEFS_SB(sb)->fs_id;
516 strncpy(new_op->upcall.req.fs_umount.orangefs_config_server,
517 ORANGEFS_SB(sb)->devname,
518 ORANGEFS_MAX_SERVER_ADDR_LEN);
519
520 gossip_debug(GOSSIP_UTILS_DEBUG,
521 "Attempting ORANGEFS Unmount via host %s\n",
522 new_op->upcall.req.fs_umount.orangefs_config_server);
523
524 ret = service_operation(new_op, "orangefs_fs_umount", 0);
525
526 gossip_debug(GOSSIP_UTILS_DEBUG,
527 "orangefs_unmount: got return value of %d\n", ret);
528 if (ret)
529 sb = ERR_PTR(ret);
530 else
531 ORANGEFS_SB(sb)->mount_pending = 1;
532
533 op_release(new_op);
534 return ret;
535 }
536
537 void orangefs_make_bad_inode(struct inode *inode)
538 {
539 if (is_root_handle(inode)) {
540 /*
541 * if this occurs, the pvfs2-client-core was killed but we
542 * can't afford to lose the inode operations and such
543 * associated with the root handle in any case.
544 */
545 gossip_debug(GOSSIP_UTILS_DEBUG,
546 "*** NOT making bad root inode %pU\n",
547 get_khandle_from_ino(inode));
548 } else {
549 gossip_debug(GOSSIP_UTILS_DEBUG,
550 "*** making bad inode %pU\n",
551 get_khandle_from_ino(inode));
552 make_bad_inode(inode);
553 }
554 }
555
556 /*
557 * The following is a very dirty hack that is now a permanent part of the
558 * ORANGEFS protocol. See protocol.h for more error definitions.
559 */
560
561 /* The order matches include/orangefs-types.h in the OrangeFS source. */
562 static int PINT_errno_mapping[] = {
563 0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM,
564 EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE,
565 EFBIG, ENOSPC, EROFS, EMLINK, EPIPE, EDEADLK, ENAMETOOLONG,
566 ENOLCK, ENOSYS, ENOTEMPTY, ELOOP, EWOULDBLOCK, ENOMSG, EUNATCH,
567 EBADR, EDEADLOCK, ENODATA, ETIME, ENONET, EREMOTE, ECOMM,
568 EPROTO, EBADMSG, EOVERFLOW, ERESTART, EMSGSIZE, EPROTOTYPE,
569 ENOPROTOOPT, EPROTONOSUPPORT, EOPNOTSUPP, EADDRINUSE,
570 EADDRNOTAVAIL, ENETDOWN, ENETUNREACH, ENETRESET, ENOBUFS,
571 ETIMEDOUT, ECONNREFUSED, EHOSTDOWN, EHOSTUNREACH, EALREADY,
572 EACCES, ECONNRESET, ERANGE
573 };
574
575 int orangefs_normalize_to_errno(__s32 error_code)
576 {
577 __u32 i;
578
579 /* Success */
580 if (error_code == 0) {
581 return 0;
582 /*
583 * This shouldn't ever happen. If it does it should be fixed on the
584 * server.
585 */
586 } else if (error_code > 0) {
587 gossip_err("orangefs: error status receieved.\n");
588 gossip_err("orangefs: assuming error code is inverted.\n");
589 error_code = -error_code;
590 }
591
592 /*
593 * XXX: This is very bad since error codes from ORANGEFS may not be
594 * suitable for return into userspace.
595 */
596
597 /*
598 * Convert ORANGEFS error values into errno values suitable for return
599 * from the kernel.
600 */
601 if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) {
602 if (((-error_code) &
603 (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT|
604 ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) {
605 /*
606 * cancellation error codes generally correspond to
607 * a timeout from the client's perspective
608 */
609 error_code = -ETIMEDOUT;
610 } else {
611 /* assume a default error code */
612 gossip_err("orangefs: warning: got error code without errno equivalent: %d.\n", error_code);
613 error_code = -EINVAL;
614 }
615
616 /* Convert ORANGEFS encoded errno values into regular errno values. */
617 } else if ((-error_code) & ORANGEFS_ERROR_BIT) {
618 i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS);
619 if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping))
620 error_code = -PINT_errno_mapping[i];
621 else
622 error_code = -EINVAL;
623
624 /*
625 * Only ORANGEFS protocol error codes should ever come here. Otherwise
626 * there is a bug somewhere.
627 */
628 } else {
629 gossip_err("orangefs: orangefs_normalize_to_errno: got error code which is not from ORANGEFS.\n");
630 }
631 return error_code;
632 }
633
634 #define NUM_MODES 11
635 __s32 ORANGEFS_util_translate_mode(int mode)
636 {
637 int ret = 0;
638 int i = 0;
639 static int modes[NUM_MODES] = {
640 S_IXOTH, S_IWOTH, S_IROTH,
641 S_IXGRP, S_IWGRP, S_IRGRP,
642 S_IXUSR, S_IWUSR, S_IRUSR,
643 S_ISGID, S_ISUID
644 };
645 static int orangefs_modes[NUM_MODES] = {
646 ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ,
647 ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ,
648 ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ,
649 ORANGEFS_G_SGID, ORANGEFS_U_SUID
650 };
651
652 for (i = 0; i < NUM_MODES; i++)
653 if (mode & modes[i])
654 ret |= orangefs_modes[i];
655
656 return ret;
657 }
658 #undef NUM_MODES
659
660 /*
661 * After obtaining a string representation of the client's debug
662 * keywords and their associated masks, this function is called to build an
663 * array of these values.
664 */
665 int orangefs_prepare_cdm_array(char *debug_array_string)
666 {
667 int i;
668 int rc = -EINVAL;
669 char *cds_head = NULL;
670 char *cds_delimiter = NULL;
671 int keyword_len = 0;
672
673 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
674
675 /*
676 * figure out how many elements the cdm_array needs.
677 */
678 for (i = 0; i < strlen(debug_array_string); i++)
679 if (debug_array_string[i] == '\n')
680 cdm_element_count++;
681
682 if (!cdm_element_count) {
683 pr_info("No elements in client debug array string!\n");
684 goto out;
685 }
686
687 cdm_array =
688 kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
689 GFP_KERNEL);
690 if (!cdm_array) {
691 pr_info("malloc failed for cdm_array!\n");
692 rc = -ENOMEM;
693 goto out;
694 }
695
696 cds_head = debug_array_string;
697
698 for (i = 0; i < cdm_element_count; i++) {
699 cds_delimiter = strchr(cds_head, '\n');
700 *cds_delimiter = '\0';
701
702 keyword_len = strcspn(cds_head, " ");
703
704 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
705 if (!cdm_array[i].keyword) {
706 rc = -ENOMEM;
707 goto out;
708 }
709
710 sscanf(cds_head,
711 "%s %llx %llx",
712 cdm_array[i].keyword,
713 (unsigned long long *)&(cdm_array[i].mask1),
714 (unsigned long long *)&(cdm_array[i].mask2));
715
716 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
717 client_verbose_index = i;
718
719 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
720 client_all_index = i;
721
722 cds_head = cds_delimiter + 1;
723 }
724
725 rc = cdm_element_count;
726
727 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
728
729 out:
730
731 return rc;
732
733 }
734
735 /*
736 * /sys/kernel/debug/orangefs/debug-help can be catted to
737 * see all the available kernel and client debug keywords.
738 *
739 * When the kernel boots, we have no idea what keywords the
740 * client supports, nor their associated masks.
741 *
742 * We pass through this function once at boot and stamp a
743 * boilerplate "we don't know" message for the client in the
744 * debug-help file. We pass through here again when the client
745 * starts and then we can fill out the debug-help file fully.
746 *
747 * The client might be restarted any number of times between
748 * reboots, we only build the debug-help file the first time.
749 */
750 int orangefs_prepare_debugfs_help_string(int at_boot)
751 {
752 int rc = -EINVAL;
753 int i;
754 int byte_count = 0;
755 char *client_title = "Client Debug Keywords:\n";
756 char *kernel_title = "Kernel Debug Keywords:\n";
757
758 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
759
760 if (at_boot) {
761 byte_count += strlen(HELP_STRING_UNINITIALIZED);
762 client_title = HELP_STRING_UNINITIALIZED;
763 } else {
764 /*
765 * fill the client keyword/mask array and remember
766 * how many elements there were.
767 */
768 cdm_element_count =
769 orangefs_prepare_cdm_array(client_debug_array_string);
770 if (cdm_element_count <= 0)
771 goto out;
772
773 /* Count the bytes destined for debug_help_string. */
774 byte_count += strlen(client_title);
775
776 for (i = 0; i < cdm_element_count; i++) {
777 byte_count += strlen(cdm_array[i].keyword + 2);
778 if (byte_count >= DEBUG_HELP_STRING_SIZE) {
779 pr_info("%s: overflow 1!\n", __func__);
780 goto out;
781 }
782 }
783
784 gossip_debug(GOSSIP_UTILS_DEBUG,
785 "%s: cdm_element_count:%d:\n",
786 __func__,
787 cdm_element_count);
788 }
789
790 byte_count += strlen(kernel_title);
791 for (i = 0; i < num_kmod_keyword_mask_map; i++) {
792 byte_count +=
793 strlen(s_kmod_keyword_mask_map[i].keyword + 2);
794 if (byte_count >= DEBUG_HELP_STRING_SIZE) {
795 pr_info("%s: overflow 2!\n", __func__);
796 goto out;
797 }
798 }
799
800 /* build debug_help_string. */
801 debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
802 if (!debug_help_string) {
803 rc = -ENOMEM;
804 goto out;
805 }
806
807 strcat(debug_help_string, client_title);
808
809 if (!at_boot) {
810 for (i = 0; i < cdm_element_count; i++) {
811 strcat(debug_help_string, "\t");
812 strcat(debug_help_string, cdm_array[i].keyword);
813 strcat(debug_help_string, "\n");
814 }
815 }
816
817 strcat(debug_help_string, "\n");
818 strcat(debug_help_string, kernel_title);
819
820 for (i = 0; i < num_kmod_keyword_mask_map; i++) {
821 strcat(debug_help_string, "\t");
822 strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
823 strcat(debug_help_string, "\n");
824 }
825
826 rc = 0;
827
828 out:
829
830 return rc;
831
832 }
833
834 /*
835 * kernel = type 0
836 * client = type 1
837 */
838 void debug_mask_to_string(void *mask, int type)
839 {
840 int i;
841 int len = 0;
842 char *debug_string;
843 int element_count = 0;
844
845 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
846
847 if (type) {
848 debug_string = client_debug_string;
849 element_count = cdm_element_count;
850 } else {
851 debug_string = kernel_debug_string;
852 element_count = num_kmod_keyword_mask_map;
853 }
854
855 memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
856
857 /*
858 * Some keywords, like "all" or "verbose", are amalgams of
859 * numerous other keywords. Make a special check for those
860 * before grinding through the whole mask only to find out
861 * later...
862 */
863 if (check_amalgam_keyword(mask, type))
864 goto out;
865
866 /* Build the debug string. */
867 for (i = 0; i < element_count; i++)
868 if (type)
869 do_c_string(mask, i);
870 else
871 do_k_string(mask, i);
872
873 len = strlen(debug_string);
874
875 if ((len) && (type))
876 client_debug_string[len - 1] = '\0';
877 else if (len)
878 kernel_debug_string[len - 1] = '\0';
879 else if (type)
880 strcpy(client_debug_string, "none");
881 else
882 strcpy(kernel_debug_string, "none");
883
884 out:
885 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
886
887 return;
888
889 }
890
891 void do_k_string(void *k_mask, int index)
892 {
893 __u64 *mask = (__u64 *) k_mask;
894
895 if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
896 goto out;
897
898 if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
899 if ((strlen(kernel_debug_string) +
900 strlen(s_kmod_keyword_mask_map[index].keyword))
901 < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
902 strcat(kernel_debug_string,
903 s_kmod_keyword_mask_map[index].keyword);
904 strcat(kernel_debug_string, ",");
905 } else {
906 gossip_err("%s: overflow!\n", __func__);
907 strcpy(kernel_debug_string, ORANGEFS_ALL);
908 goto out;
909 }
910 }
911
912 out:
913
914 return;
915 }
916
917 void do_c_string(void *c_mask, int index)
918 {
919 struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
920
921 if (keyword_is_amalgam(cdm_array[index].keyword))
922 goto out;
923
924 if ((mask->mask1 & cdm_array[index].mask1) ||
925 (mask->mask2 & cdm_array[index].mask2)) {
926 if ((strlen(client_debug_string) +
927 strlen(cdm_array[index].keyword) + 1)
928 < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
929 strcat(client_debug_string,
930 cdm_array[index].keyword);
931 strcat(client_debug_string, ",");
932 } else {
933 gossip_err("%s: overflow!\n", __func__);
934 strcpy(client_debug_string, ORANGEFS_ALL);
935 goto out;
936 }
937 }
938 out:
939 return;
940 }
941
942 int keyword_is_amalgam(char *keyword)
943 {
944 int rc = 0;
945
946 if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
947 rc = 1;
948
949 return rc;
950 }
951
952 /*
953 * kernel = type 0
954 * client = type 1
955 *
956 * return 1 if we found an amalgam.
957 */
958 int check_amalgam_keyword(void *mask, int type)
959 {
960 __u64 *k_mask;
961 struct client_debug_mask *c_mask;
962 int k_all_index = num_kmod_keyword_mask_map - 1;
963 int rc = 0;
964
965 if (type) {
966 c_mask = (struct client_debug_mask *) mask;
967
968 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
969 (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
970 strcpy(client_debug_string, ORANGEFS_ALL);
971 rc = 1;
972 goto out;
973 }
974
975 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
976 (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
977 strcpy(client_debug_string, ORANGEFS_VERBOSE);
978 rc = 1;
979 goto out;
980 }
981
982 } else {
983 k_mask = (__u64 *) mask;
984
985 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
986 strcpy(kernel_debug_string, ORANGEFS_ALL);
987 rc = 1;
988 goto out;
989 }
990 }
991
992 out:
993
994 return rc;
995 }
996
997 /*
998 * kernel = type 0
999 * client = type 1
1000 */
1001 void debug_string_to_mask(char *debug_string, void *mask, int type)
1002 {
1003 char *unchecked_keyword;
1004 int i;
1005 char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
1006 char *original_pointer;
1007 int element_count = 0;
1008 struct client_debug_mask *c_mask;
1009 __u64 *k_mask;
1010
1011 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
1012
1013 if (type) {
1014 c_mask = (struct client_debug_mask *)mask;
1015 element_count = cdm_element_count;
1016 } else {
1017 k_mask = (__u64 *)mask;
1018 *k_mask = 0;
1019 element_count = num_kmod_keyword_mask_map;
1020 }
1021
1022 original_pointer = strsep_fodder;
1023 while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
1024 if (strlen(unchecked_keyword)) {
1025 for (i = 0; i < element_count; i++)
1026 if (type)
1027 do_c_mask(i,
1028 unchecked_keyword,
1029 &c_mask);
1030 else
1031 do_k_mask(i,
1032 unchecked_keyword,
1033 &k_mask);
1034 }
1035
1036 kfree(original_pointer);
1037 }
1038
1039 void do_c_mask(int i,
1040 char *unchecked_keyword,
1041 struct client_debug_mask **sane_mask)
1042 {
1043
1044 if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
1045 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
1046 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
1047 }
1048 }
1049
1050 void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
1051 {
1052
1053 if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
1054 **sane_mask = (**sane_mask) |
1055 s_kmod_keyword_mask_map[i].mask_val;
1056 }
Linux with added FPC-III support