?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
powerpc/kprobes: Remove kretprobe_trampoline_holder.
[linux/fpc-iii.git] / fs / orangefs / orangefs-utils.c
blob2d129b5886eeb7a61d067502900dca75cf525d08
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(current_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(current_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 size)
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 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
265 if (!new_op)
266 return -ENOMEM;
267 new_op->upcall.req.getattr.refn = orangefs_inode->refn;
268 new_op->upcall.req.getattr.mask = size ?
269 ORANGEFS_ATTR_SYS_ALL_NOHINT : ORANGEFS_ATTR_SYS_ALL_NOHINT_NOSIZE;
270
271 ret = service_operation(new_op, __func__,
272 get_interruptible_flag(inode));
273 if (ret != 0)
274 goto out;
275
276 type = orangefs_inode_type(new_op->
277 downcall.resp.getattr.attributes.objtype);
278 ret = orangefs_inode_is_stale(inode, new,
279 &new_op->downcall.resp.getattr.attributes,
280 new_op->downcall.resp.getattr.link_target);
281 if (ret) {
282 ret = -ESTALE;
283 goto out;
284 }
285
286 switch (type) {
287 case S_IFREG:
288 inode->i_flags = orangefs_inode_flags(&new_op->
289 downcall.resp.getattr.attributes);
290 if (size) {
291 inode_size = (loff_t)new_op->
292 downcall.resp.getattr.attributes.size;
293 rounded_up_size =
294 (inode_size + (4096 - (inode_size % 4096)));
295 inode->i_size = inode_size;
296 orangefs_inode->blksize =
297 new_op->downcall.resp.getattr.attributes.blksize;
298 spin_lock(&inode->i_lock);
299 inode->i_bytes = inode_size;
300 inode->i_blocks =
301 (unsigned long)(rounded_up_size / 512);
302 spin_unlock(&inode->i_lock);
303 }
304 break;
305 case S_IFDIR:
306 inode->i_size = PAGE_SIZE;
307 orangefs_inode->blksize = (1 << inode->i_blkbits);
308 spin_lock(&inode->i_lock);
309 inode_set_bytes(inode, inode->i_size);
310 spin_unlock(&inode->i_lock);
311 set_nlink(inode, 1);
312 break;
313 case S_IFLNK:
314 if (new) {
315 inode->i_size = (loff_t)strlen(new_op->
316 downcall.resp.getattr.link_target);
317 orangefs_inode->blksize = (1 << inode->i_blkbits);
318 ret = strscpy(orangefs_inode->link_target,
319 new_op->downcall.resp.getattr.link_target,
320 ORANGEFS_NAME_MAX);
321 if (ret == -E2BIG) {
322 ret = -EIO;
323 goto out;
324 }
325 inode->i_link = orangefs_inode->link_target;
326 }
327 break;
328 }
329
330 inode->i_uid = make_kuid(&init_user_ns, new_op->
331 downcall.resp.getattr.attributes.owner);
332 inode->i_gid = make_kgid(&init_user_ns, new_op->
333 downcall.resp.getattr.attributes.group);
334 inode->i_atime.tv_sec = (time64_t)new_op->
335 downcall.resp.getattr.attributes.atime;
336 inode->i_mtime.tv_sec = (time64_t)new_op->
337 downcall.resp.getattr.attributes.mtime;
338 inode->i_ctime.tv_sec = (time64_t)new_op->
339 downcall.resp.getattr.attributes.ctime;
340 inode->i_atime.tv_nsec = 0;
341 inode->i_mtime.tv_nsec = 0;
342 inode->i_ctime.tv_nsec = 0;
343
344 /* special case: mark the root inode as sticky */
345 inode->i_mode = type | (is_root_handle(inode) ? S_ISVTX : 0) |
346 orangefs_inode_perms(&new_op->downcall.resp.getattr.attributes);
347
348 ret = 0;
349 out:
350 op_release(new_op);
351 return ret;
352 }
353
354 int orangefs_inode_check_changed(struct inode *inode)
355 {
356 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
357 struct orangefs_kernel_op_s *new_op;
358 int ret;
359
360 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__,
361 get_khandle_from_ino(inode));
362
363 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
364 if (!new_op)
365 return -ENOMEM;
366 new_op->upcall.req.getattr.refn = orangefs_inode->refn;
367 new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_TYPE |
368 ORANGEFS_ATTR_SYS_LNK_TARGET;
369
370 ret = service_operation(new_op, __func__,
371 get_interruptible_flag(inode));
372 if (ret != 0)
373 goto out;
374
375 ret = orangefs_inode_is_stale(inode, 0,
376 &new_op->downcall.resp.getattr.attributes,
377 new_op->downcall.resp.getattr.link_target);
378 out:
379 op_release(new_op);
380 return ret;
381 }
382
383 /*
384 * issues a orangefs setattr request to make sure the new attribute values
385 * take effect if successful. returns 0 on success; -errno otherwise
386 */
387 int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr)
388 {
389 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
390 struct orangefs_kernel_op_s *new_op;
391 int ret;
392
393 new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR);
394 if (!new_op)
395 return -ENOMEM;
396
397 new_op->upcall.req.setattr.refn = orangefs_inode->refn;
398 ret = copy_attributes_from_inode(inode,
399 &new_op->upcall.req.setattr.attributes,
400 iattr);
401 if (ret >= 0) {
402 ret = service_operation(new_op, __func__,
403 get_interruptible_flag(inode));
404
405 gossip_debug(GOSSIP_UTILS_DEBUG,
406 "orangefs_inode_setattr: returning %d\n",
407 ret);
408 }
409
410 op_release(new_op);
411
412 /*
413 * successful setattr should clear the atime, mtime and
414 * ctime flags.
415 */
416 if (ret == 0) {
417 ClearAtimeFlag(orangefs_inode);
418 ClearMtimeFlag(orangefs_inode);
419 ClearCtimeFlag(orangefs_inode);
420 ClearModeFlag(orangefs_inode);
421 }
422
423 return ret;
424 }
425
426 int orangefs_flush_inode(struct inode *inode)
427 {
428 /*
429 * If it is a dirty inode, this function gets called.
430 * Gather all the information that needs to be setattr'ed
431 * Right now, this will only be used for mode, atime, mtime
432 * and/or ctime.
433 */
434 struct iattr wbattr;
435 int ret;
436 int mtime_flag;
437 int ctime_flag;
438 int atime_flag;
439 int mode_flag;
440 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
441
442 memset(&wbattr, 0, sizeof(wbattr));
443
444 /*
445 * check inode flags up front, and clear them if they are set. This
446 * will prevent multiple processes from all trying to flush the same
447 * inode if they call close() simultaneously
448 */
449 mtime_flag = MtimeFlag(orangefs_inode);
450 ClearMtimeFlag(orangefs_inode);
451 ctime_flag = CtimeFlag(orangefs_inode);
452 ClearCtimeFlag(orangefs_inode);
453 atime_flag = AtimeFlag(orangefs_inode);
454 ClearAtimeFlag(orangefs_inode);
455 mode_flag = ModeFlag(orangefs_inode);
456 ClearModeFlag(orangefs_inode);
457
458 /* -- Lazy atime,mtime and ctime update --
459 * Note: all times are dictated by server in the new scheme
460 * and not by the clients
461 *
462 * Also mode updates are being handled now..
463 */
464
465 if (mtime_flag)
466 wbattr.ia_valid |= ATTR_MTIME;
467 if (ctime_flag)
468 wbattr.ia_valid |= ATTR_CTIME;
469 if (atime_flag)
470 wbattr.ia_valid |= ATTR_ATIME;
471
472 if (mode_flag) {
473 wbattr.ia_mode = inode->i_mode;
474 wbattr.ia_valid |= ATTR_MODE;
475 }
476
477 gossip_debug(GOSSIP_UTILS_DEBUG,
478 "*********** orangefs_flush_inode: %pU "
479 "(ia_valid %d)\n",
480 get_khandle_from_ino(inode),
481 wbattr.ia_valid);
482 if (wbattr.ia_valid == 0) {
483 gossip_debug(GOSSIP_UTILS_DEBUG,
484 "orangefs_flush_inode skipping setattr()\n");
485 return 0;
486 }
487
488 gossip_debug(GOSSIP_UTILS_DEBUG,
489 "orangefs_flush_inode (%pU) writing mode %o\n",
490 get_khandle_from_ino(inode),
491 inode->i_mode);
492
493 ret = orangefs_inode_setattr(inode, &wbattr);
494
495 return ret;
496 }
497
498 int orangefs_unmount_sb(struct super_block *sb)
499 {
500 int ret = -EINVAL;
501 struct orangefs_kernel_op_s *new_op = NULL;
502
503 gossip_debug(GOSSIP_UTILS_DEBUG,
504 "orangefs_unmount_sb called on sb %p\n",
505 sb);
506
507 new_op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT);
508 if (!new_op)
509 return -ENOMEM;
510 new_op->upcall.req.fs_umount.id = ORANGEFS_SB(sb)->id;
511 new_op->upcall.req.fs_umount.fs_id = ORANGEFS_SB(sb)->fs_id;
512 strncpy(new_op->upcall.req.fs_umount.orangefs_config_server,
513 ORANGEFS_SB(sb)->devname,
514 ORANGEFS_MAX_SERVER_ADDR_LEN);
515
516 gossip_debug(GOSSIP_UTILS_DEBUG,
517 "Attempting ORANGEFS Unmount via host %s\n",
518 new_op->upcall.req.fs_umount.orangefs_config_server);
519
520 ret = service_operation(new_op, "orangefs_fs_umount", 0);
521
522 gossip_debug(GOSSIP_UTILS_DEBUG,
523 "orangefs_unmount: got return value of %d\n", ret);
524 if (ret)
525 sb = ERR_PTR(ret);
526 else
527 ORANGEFS_SB(sb)->mount_pending = 1;
528
529 op_release(new_op);
530 return ret;
531 }
532
533 void orangefs_make_bad_inode(struct inode *inode)
534 {
535 if (is_root_handle(inode)) {
536 /*
537 * if this occurs, the pvfs2-client-core was killed but we
538 * can't afford to lose the inode operations and such
539 * associated with the root handle in any case.
540 */
541 gossip_debug(GOSSIP_UTILS_DEBUG,
542 "*** NOT making bad root inode %pU\n",
543 get_khandle_from_ino(inode));
544 } else {
545 gossip_debug(GOSSIP_UTILS_DEBUG,
546 "*** making bad inode %pU\n",
547 get_khandle_from_ino(inode));
548 make_bad_inode(inode);
549 }
550 }
551
552 /*
553 * The following is a very dirty hack that is now a permanent part of the
554 * ORANGEFS protocol. See protocol.h for more error definitions.
555 */
556
557 /* The order matches include/orangefs-types.h in the OrangeFS source. */
558 static int PINT_errno_mapping[] = {
559 0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM,
560 EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE,
561 EFBIG, ENOSPC, EROFS, EMLINK, EPIPE, EDEADLK, ENAMETOOLONG,
562 ENOLCK, ENOSYS, ENOTEMPTY, ELOOP, EWOULDBLOCK, ENOMSG, EUNATCH,
563 EBADR, EDEADLOCK, ENODATA, ETIME, ENONET, EREMOTE, ECOMM,
564 EPROTO, EBADMSG, EOVERFLOW, ERESTART, EMSGSIZE, EPROTOTYPE,
565 ENOPROTOOPT, EPROTONOSUPPORT, EOPNOTSUPP, EADDRINUSE,
566 EADDRNOTAVAIL, ENETDOWN, ENETUNREACH, ENETRESET, ENOBUFS,
567 ETIMEDOUT, ECONNREFUSED, EHOSTDOWN, EHOSTUNREACH, EALREADY,
568 EACCES, ECONNRESET, ERANGE
569 };
570
571 int orangefs_normalize_to_errno(__s32 error_code)
572 {
573 __u32 i;
574
575 /* Success */
576 if (error_code == 0) {
577 return 0;
578 /*
579 * This shouldn't ever happen. If it does it should be fixed on the
580 * server.
581 */
582 } else if (error_code > 0) {
583 gossip_err("orangefs: error status receieved.\n");
584 gossip_err("orangefs: assuming error code is inverted.\n");
585 error_code = -error_code;
586 }
587
588 /*
589 * XXX: This is very bad since error codes from ORANGEFS may not be
590 * suitable for return into userspace.
591 */
592
593 /*
594 * Convert ORANGEFS error values into errno values suitable for return
595 * from the kernel.
596 */
597 if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) {
598 if (((-error_code) &
599 (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT|
600 ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) {
601 /*
602 * cancellation error codes generally correspond to
603 * a timeout from the client's perspective
604 */
605 error_code = -ETIMEDOUT;
606 } else {
607 /* assume a default error code */
608 gossip_err("orangefs: warning: got error code without errno equivalent: %d.\n", error_code);
609 error_code = -EINVAL;
610 }
611
612 /* Convert ORANGEFS encoded errno values into regular errno values. */
613 } else if ((-error_code) & ORANGEFS_ERROR_BIT) {
614 i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS);
615 if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping))
616 error_code = -PINT_errno_mapping[i];
617 else
618 error_code = -EINVAL;
619
620 /*
621 * Only ORANGEFS protocol error codes should ever come here. Otherwise
622 * there is a bug somewhere.
623 */
624 } else {
625 gossip_err("orangefs: orangefs_normalize_to_errno: got error code which is not from ORANGEFS.\n");
626 }
627 return error_code;
628 }
629
630 #define NUM_MODES 11
631 __s32 ORANGEFS_util_translate_mode(int mode)
632 {
633 int ret = 0;
634 int i = 0;
635 static int modes[NUM_MODES] = {
636 S_IXOTH, S_IWOTH, S_IROTH,
637 S_IXGRP, S_IWGRP, S_IRGRP,
638 S_IXUSR, S_IWUSR, S_IRUSR,
639 S_ISGID, S_ISUID
640 };
641 static int orangefs_modes[NUM_MODES] = {
642 ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ,
643 ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ,
644 ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ,
645 ORANGEFS_G_SGID, ORANGEFS_U_SUID
646 };
647
648 for (i = 0; i < NUM_MODES; i++)
649 if (mode & modes[i])
650 ret |= orangefs_modes[i];
651
652 return ret;
653 }
654 #undef NUM_MODES
655
656 /*
657 * After obtaining a string representation of the client's debug
658 * keywords and their associated masks, this function is called to build an
659 * array of these values.
660 */
661 int orangefs_prepare_cdm_array(char *debug_array_string)
662 {
663 int i;
664 int rc = -EINVAL;
665 char *cds_head = NULL;
666 char *cds_delimiter = NULL;
667 int keyword_len = 0;
668
669 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
670
671 /*
672 * figure out how many elements the cdm_array needs.
673 */
674 for (i = 0; i < strlen(debug_array_string); i++)
675 if (debug_array_string[i] == '\n')
676 cdm_element_count++;
677
678 if (!cdm_element_count) {
679 pr_info("No elements in client debug array string!\n");
680 goto out;
681 }
682
683 cdm_array =
684 kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
685 GFP_KERNEL);
686 if (!cdm_array) {
687 pr_info("malloc failed for cdm_array!\n");
688 rc = -ENOMEM;
689 goto out;
690 }
691
692 cds_head = debug_array_string;
693
694 for (i = 0; i < cdm_element_count; i++) {
695 cds_delimiter = strchr(cds_head, '\n');
696 *cds_delimiter = '\0';
697
698 keyword_len = strcspn(cds_head, " ");
699
700 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
701 if (!cdm_array[i].keyword) {
702 rc = -ENOMEM;
703 goto out;
704 }
705
706 sscanf(cds_head,
707 "%s %llx %llx",
708 cdm_array[i].keyword,
709 (unsigned long long *)&(cdm_array[i].mask1),
710 (unsigned long long *)&(cdm_array[i].mask2));
711
712 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
713 client_verbose_index = i;
714
715 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
716 client_all_index = i;
717
718 cds_head = cds_delimiter + 1;
719 }
720
721 rc = cdm_element_count;
722
723 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
724
725 out:
726
727 return rc;
728
729 }
730
731 /*
732 * /sys/kernel/debug/orangefs/debug-help can be catted to
733 * see all the available kernel and client debug keywords.
734 *
735 * When the kernel boots, we have no idea what keywords the
736 * client supports, nor their associated masks.
737 *
738 * We pass through this function once at boot and stamp a
739 * boilerplate "we don't know" message for the client in the
740 * debug-help file. We pass through here again when the client
741 * starts and then we can fill out the debug-help file fully.
742 *
743 * The client might be restarted any number of times between
744 * reboots, we only build the debug-help file the first time.
745 */
746 int orangefs_prepare_debugfs_help_string(int at_boot)
747 {
748 int rc = -EINVAL;
749 int i;
750 int byte_count = 0;
751 char *client_title = "Client Debug Keywords:\n";
752 char *kernel_title = "Kernel Debug Keywords:\n";
753
754 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
755
756 if (at_boot) {
757 byte_count += strlen(HELP_STRING_UNINITIALIZED);
758 client_title = HELP_STRING_UNINITIALIZED;
759 } else {
760 /*
761 * fill the client keyword/mask array and remember
762 * how many elements there were.
763 */
764 cdm_element_count =
765 orangefs_prepare_cdm_array(client_debug_array_string);
766 if (cdm_element_count <= 0)
767 goto out;
768
769 /* Count the bytes destined for debug_help_string. */
770 byte_count += strlen(client_title);
771
772 for (i = 0; i < cdm_element_count; i++) {
773 byte_count += strlen(cdm_array[i].keyword + 2);
774 if (byte_count >= DEBUG_HELP_STRING_SIZE) {
775 pr_info("%s: overflow 1!\n", __func__);
776 goto out;
777 }
778 }
779
780 gossip_debug(GOSSIP_UTILS_DEBUG,
781 "%s: cdm_element_count:%d:\n",
782 __func__,
783 cdm_element_count);
784 }
785
786 byte_count += strlen(kernel_title);
787 for (i = 0; i < num_kmod_keyword_mask_map; i++) {
788 byte_count +=
789 strlen(s_kmod_keyword_mask_map[i].keyword + 2);
790 if (byte_count >= DEBUG_HELP_STRING_SIZE) {
791 pr_info("%s: overflow 2!\n", __func__);
792 goto out;
793 }
794 }
795
796 /* build debug_help_string. */
797 debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
798 if (!debug_help_string) {
799 rc = -ENOMEM;
800 goto out;
801 }
802
803 strcat(debug_help_string, client_title);
804
805 if (!at_boot) {
806 for (i = 0; i < cdm_element_count; i++) {
807 strcat(debug_help_string, "\t");
808 strcat(debug_help_string, cdm_array[i].keyword);
809 strcat(debug_help_string, "\n");
810 }
811 }
812
813 strcat(debug_help_string, "\n");
814 strcat(debug_help_string, kernel_title);
815
816 for (i = 0; i < num_kmod_keyword_mask_map; i++) {
817 strcat(debug_help_string, "\t");
818 strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
819 strcat(debug_help_string, "\n");
820 }
821
822 rc = 0;
823
824 out:
825
826 return rc;
827
828 }
829
830 /*
831 * kernel = type 0
832 * client = type 1
833 */
834 void debug_mask_to_string(void *mask, int type)
835 {
836 int i;
837 int len = 0;
838 char *debug_string;
839 int element_count = 0;
840
841 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
842
843 if (type) {
844 debug_string = client_debug_string;
845 element_count = cdm_element_count;
846 } else {
847 debug_string = kernel_debug_string;
848 element_count = num_kmod_keyword_mask_map;
849 }
850
851 memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
852
853 /*
854 * Some keywords, like "all" or "verbose", are amalgams of
855 * numerous other keywords. Make a special check for those
856 * before grinding through the whole mask only to find out
857 * later...
858 */
859 if (check_amalgam_keyword(mask, type))
860 goto out;
861
862 /* Build the debug string. */
863 for (i = 0; i < element_count; i++)
864 if (type)
865 do_c_string(mask, i);
866 else
867 do_k_string(mask, i);
868
869 len = strlen(debug_string);
870
871 if ((len) && (type))
872 client_debug_string[len - 1] = '\0';
873 else if (len)
874 kernel_debug_string[len - 1] = '\0';
875 else if (type)
876 strcpy(client_debug_string, "none");
877 else
878 strcpy(kernel_debug_string, "none");
879
880 out:
881 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
882
883 return;
884
885 }
886
887 void do_k_string(void *k_mask, int index)
888 {
889 __u64 *mask = (__u64 *) k_mask;
890
891 if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
892 goto out;
893
894 if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
895 if ((strlen(kernel_debug_string) +
896 strlen(s_kmod_keyword_mask_map[index].keyword))
897 < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
898 strcat(kernel_debug_string,
899 s_kmod_keyword_mask_map[index].keyword);
900 strcat(kernel_debug_string, ",");
901 } else {
902 gossip_err("%s: overflow!\n", __func__);
903 strcpy(kernel_debug_string, ORANGEFS_ALL);
904 goto out;
905 }
906 }
907
908 out:
909
910 return;
911 }
912
913 void do_c_string(void *c_mask, int index)
914 {
915 struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
916
917 if (keyword_is_amalgam(cdm_array[index].keyword))
918 goto out;
919
920 if ((mask->mask1 & cdm_array[index].mask1) ||
921 (mask->mask2 & cdm_array[index].mask2)) {
922 if ((strlen(client_debug_string) +
923 strlen(cdm_array[index].keyword) + 1)
924 < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
925 strcat(client_debug_string,
926 cdm_array[index].keyword);
927 strcat(client_debug_string, ",");
928 } else {
929 gossip_err("%s: overflow!\n", __func__);
930 strcpy(client_debug_string, ORANGEFS_ALL);
931 goto out;
932 }
933 }
934 out:
935 return;
936 }
937
938 int keyword_is_amalgam(char *keyword)
939 {
940 int rc = 0;
941
942 if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
943 rc = 1;
944
945 return rc;
946 }
947
948 /*
949 * kernel = type 0
950 * client = type 1
951 *
952 * return 1 if we found an amalgam.
953 */
954 int check_amalgam_keyword(void *mask, int type)
955 {
956 __u64 *k_mask;
957 struct client_debug_mask *c_mask;
958 int k_all_index = num_kmod_keyword_mask_map - 1;
959 int rc = 0;
960
961 if (type) {
962 c_mask = (struct client_debug_mask *) mask;
963
964 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
965 (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
966 strcpy(client_debug_string, ORANGEFS_ALL);
967 rc = 1;
968 goto out;
969 }
970
971 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
972 (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
973 strcpy(client_debug_string, ORANGEFS_VERBOSE);
974 rc = 1;
975 goto out;
976 }
977
978 } else {
979 k_mask = (__u64 *) mask;
980
981 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
982 strcpy(kernel_debug_string, ORANGEFS_ALL);
983 rc = 1;
984 goto out;
985 }
986 }
987
988 out:
989
990 return rc;
991 }
992
993 /*
994 * kernel = type 0
995 * client = type 1
996 */
997 void debug_string_to_mask(char *debug_string, void *mask, int type)
998 {
999 char *unchecked_keyword;
1000 int i;
1001 char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
1002 char *original_pointer;
1003 int element_count = 0;
1004 struct client_debug_mask *c_mask;
1005 __u64 *k_mask;
1006
1007 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
1008
1009 if (type) {
1010 c_mask = (struct client_debug_mask *)mask;
1011 element_count = cdm_element_count;
1012 } else {
1013 k_mask = (__u64 *)mask;
1014 *k_mask = 0;
1015 element_count = num_kmod_keyword_mask_map;
1016 }
1017
1018 original_pointer = strsep_fodder;
1019 while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
1020 if (strlen(unchecked_keyword)) {
1021 for (i = 0; i < element_count; i++)
1022 if (type)
1023 do_c_mask(i,
1024 unchecked_keyword,
1025 &c_mask);
1026 else
1027 do_k_mask(i,
1028 unchecked_keyword,
1029 &k_mask);
1030 }
1031
1032 kfree(original_pointer);
1033 }
1034
1035 void do_c_mask(int i,
1036 char *unchecked_keyword,
1037 struct client_debug_mask **sane_mask)
1038 {
1039
1040 if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
1041 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
1042 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
1043 }
1044 }
1045
1046 void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
1047 {
1048
1049 if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
1050 **sane_mask = (**sane_mask) |
1051 s_kmod_keyword_mask_map[i].mask_val;
1052 }
Linux with added FPC-III support