2 * (C) 2001 Clemson University and The University of Chicago
4 * See COPYING in top-level directory.
7 #include "orangefs-kernel.h"
8 #include "orangefs-dev-proto.h"
9 #include "orangefs-bufmap.h"
11 __s32
fsid_of_op(struct orangefs_kernel_op_s
*op
)
13 __s32 fsid
= ORANGEFS_FS_ID_NULL
;
16 switch (op
->upcall
.type
) {
17 case ORANGEFS_VFS_OP_FILE_IO
:
18 fsid
= op
->upcall
.req
.io
.refn
.fs_id
;
20 case ORANGEFS_VFS_OP_LOOKUP
:
21 fsid
= op
->upcall
.req
.lookup
.parent_refn
.fs_id
;
23 case ORANGEFS_VFS_OP_CREATE
:
24 fsid
= op
->upcall
.req
.create
.parent_refn
.fs_id
;
26 case ORANGEFS_VFS_OP_GETATTR
:
27 fsid
= op
->upcall
.req
.getattr
.refn
.fs_id
;
29 case ORANGEFS_VFS_OP_REMOVE
:
30 fsid
= op
->upcall
.req
.remove
.parent_refn
.fs_id
;
32 case ORANGEFS_VFS_OP_MKDIR
:
33 fsid
= op
->upcall
.req
.mkdir
.parent_refn
.fs_id
;
35 case ORANGEFS_VFS_OP_READDIR
:
36 fsid
= op
->upcall
.req
.readdir
.refn
.fs_id
;
38 case ORANGEFS_VFS_OP_SETATTR
:
39 fsid
= op
->upcall
.req
.setattr
.refn
.fs_id
;
41 case ORANGEFS_VFS_OP_SYMLINK
:
42 fsid
= op
->upcall
.req
.sym
.parent_refn
.fs_id
;
44 case ORANGEFS_VFS_OP_RENAME
:
45 fsid
= op
->upcall
.req
.rename
.old_parent_refn
.fs_id
;
47 case ORANGEFS_VFS_OP_STATFS
:
48 fsid
= op
->upcall
.req
.statfs
.fs_id
;
50 case ORANGEFS_VFS_OP_TRUNCATE
:
51 fsid
= op
->upcall
.req
.truncate
.refn
.fs_id
;
53 case ORANGEFS_VFS_OP_MMAP_RA_FLUSH
:
54 fsid
= op
->upcall
.req
.ra_cache_flush
.refn
.fs_id
;
56 case ORANGEFS_VFS_OP_FS_UMOUNT
:
57 fsid
= op
->upcall
.req
.fs_umount
.fs_id
;
59 case ORANGEFS_VFS_OP_GETXATTR
:
60 fsid
= op
->upcall
.req
.getxattr
.refn
.fs_id
;
62 case ORANGEFS_VFS_OP_SETXATTR
:
63 fsid
= op
->upcall
.req
.setxattr
.refn
.fs_id
;
65 case ORANGEFS_VFS_OP_LISTXATTR
:
66 fsid
= op
->upcall
.req
.listxattr
.refn
.fs_id
;
68 case ORANGEFS_VFS_OP_REMOVEXATTR
:
69 fsid
= op
->upcall
.req
.removexattr
.refn
.fs_id
;
71 case ORANGEFS_VFS_OP_FSYNC
:
72 fsid
= op
->upcall
.req
.fsync
.refn
.fs_id
;
81 static void orangefs_set_inode_flags(struct inode
*inode
,
82 struct ORANGEFS_sys_attr_s
*attrs
)
84 if (attrs
->flags
& ORANGEFS_IMMUTABLE_FL
)
85 inode
->i_flags
|= S_IMMUTABLE
;
87 inode
->i_flags
&= ~S_IMMUTABLE
;
89 if (attrs
->flags
& ORANGEFS_APPEND_FL
)
90 inode
->i_flags
|= S_APPEND
;
92 inode
->i_flags
&= ~S_APPEND
;
94 if (attrs
->flags
& ORANGEFS_NOATIME_FL
)
95 inode
->i_flags
|= S_NOATIME
;
97 inode
->i_flags
&= ~S_NOATIME
;
101 /* NOTE: symname is ignored unless the inode is a sym link */
102 static int copy_attributes_to_inode(struct inode
*inode
,
103 struct ORANGEFS_sys_attr_s
*attrs
,
108 struct orangefs_inode_s
*orangefs_inode
= ORANGEFS_I(inode
);
109 loff_t inode_size
= 0;
110 loff_t rounded_up_size
= 0;
114 * arbitrarily set the inode block size; FIXME: we need to
115 * resolve the difference between the reported inode blocksize
116 * and the PAGE_CACHE_SIZE, since our block count will always
119 * For now, we're setting the block count to be the proper
120 * number assuming the block size is 512 bytes, and the size is
121 * rounded up to the nearest 4K. This is apparently required
122 * to get proper size reports from the 'du' shell utility.
124 * changing the inode->i_blkbits to something other than
125 * PAGE_CACHE_SHIFT breaks mmap/execution as we depend on that.
127 gossip_debug(GOSSIP_UTILS_DEBUG
,
128 "attrs->mask = %x (objtype = %s)\n",
130 attrs
->objtype
== ORANGEFS_TYPE_METAFILE
? "file" :
131 attrs
->objtype
== ORANGEFS_TYPE_DIRECTORY
? "directory" :
132 attrs
->objtype
== ORANGEFS_TYPE_SYMLINK
? "symlink" :
135 switch (attrs
->objtype
) {
136 case ORANGEFS_TYPE_METAFILE
:
137 orangefs_set_inode_flags(inode
, attrs
);
138 if (attrs
->mask
& ORANGEFS_ATTR_SYS_SIZE
) {
139 inode_size
= (loff_t
) attrs
->size
;
141 (inode_size
+ (4096 - (inode_size
% 4096)));
143 orangefs_lock_inode(inode
);
144 inode
->i_bytes
= inode_size
;
146 (unsigned long)(rounded_up_size
/ 512);
147 orangefs_unlock_inode(inode
);
150 * NOTE: make sure all the places we're called
151 * from have the inode->i_sem lock. We're fine
152 * in 99% of the cases since we're mostly
153 * called from a lookup.
155 inode
->i_size
= inode_size
;
158 case ORANGEFS_TYPE_SYMLINK
:
159 if (symname
!= NULL
) {
160 inode
->i_size
= (loff_t
) strlen(symname
);
165 inode
->i_size
= PAGE_CACHE_SIZE
;
167 orangefs_lock_inode(inode
);
168 inode_set_bytes(inode
, inode
->i_size
);
169 orangefs_unlock_inode(inode
);
173 inode
->i_uid
= make_kuid(&init_user_ns
, attrs
->owner
);
174 inode
->i_gid
= make_kgid(&init_user_ns
, attrs
->group
);
175 inode
->i_atime
.tv_sec
= (time_t) attrs
->atime
;
176 inode
->i_mtime
.tv_sec
= (time_t) attrs
->mtime
;
177 inode
->i_ctime
.tv_sec
= (time_t) attrs
->ctime
;
178 inode
->i_atime
.tv_nsec
= 0;
179 inode
->i_mtime
.tv_nsec
= 0;
180 inode
->i_ctime
.tv_nsec
= 0;
182 if (attrs
->perms
& ORANGEFS_O_EXECUTE
)
183 perm_mode
|= S_IXOTH
;
184 if (attrs
->perms
& ORANGEFS_O_WRITE
)
185 perm_mode
|= S_IWOTH
;
186 if (attrs
->perms
& ORANGEFS_O_READ
)
187 perm_mode
|= S_IROTH
;
189 if (attrs
->perms
& ORANGEFS_G_EXECUTE
)
190 perm_mode
|= S_IXGRP
;
191 if (attrs
->perms
& ORANGEFS_G_WRITE
)
192 perm_mode
|= S_IWGRP
;
193 if (attrs
->perms
& ORANGEFS_G_READ
)
194 perm_mode
|= S_IRGRP
;
196 if (attrs
->perms
& ORANGEFS_U_EXECUTE
)
197 perm_mode
|= S_IXUSR
;
198 if (attrs
->perms
& ORANGEFS_U_WRITE
)
199 perm_mode
|= S_IWUSR
;
200 if (attrs
->perms
& ORANGEFS_U_READ
)
201 perm_mode
|= S_IRUSR
;
203 if (attrs
->perms
& ORANGEFS_G_SGID
)
204 perm_mode
|= S_ISGID
;
205 if (attrs
->perms
& ORANGEFS_U_SUID
)
206 perm_mode
|= S_ISUID
;
208 inode
->i_mode
= perm_mode
;
210 if (is_root_handle(inode
)) {
211 /* special case: mark the root inode as sticky */
212 inode
->i_mode
|= S_ISVTX
;
213 gossip_debug(GOSSIP_UTILS_DEBUG
,
214 "Marking inode %pU as sticky\n",
215 get_khandle_from_ino(inode
));
218 switch (attrs
->objtype
) {
219 case ORANGEFS_TYPE_METAFILE
:
220 inode
->i_mode
|= S_IFREG
;
223 case ORANGEFS_TYPE_DIRECTORY
:
224 inode
->i_mode
|= S_IFDIR
;
225 /* NOTE: we have no good way to keep nlink consistent
226 * for directories across clients; keep constant at 1.
227 * Why 1? If we go with 2, then find(1) gets confused
228 * and won't work properly withouth the -noleaf option
233 case ORANGEFS_TYPE_SYMLINK
:
234 inode
->i_mode
|= S_IFLNK
;
236 /* copy link target to inode private data */
237 if (orangefs_inode
&& symname
) {
238 strncpy(orangefs_inode
->link_target
,
241 gossip_debug(GOSSIP_UTILS_DEBUG
,
242 "Copied attr link target %s\n",
243 orangefs_inode
->link_target
);
245 gossip_debug(GOSSIP_UTILS_DEBUG
,
251 gossip_err("orangefs: copy_attributes_to_inode: got invalid attribute type %x\n",
255 gossip_debug(GOSSIP_UTILS_DEBUG
,
256 "orangefs: copy_attributes_to_inode: setting i_mode to %o, i_size to %lu\n",
258 (unsigned long)i_size_read(inode
));
264 * NOTE: in kernel land, we never use the sys_attr->link_target for
265 * anything, so don't bother copying it into the sys_attr object here.
267 static inline int copy_attributes_from_inode(struct inode
*inode
,
268 struct ORANGEFS_sys_attr_s
*attrs
,
273 if (!iattr
|| !inode
|| !attrs
) {
274 gossip_err("NULL iattr (%p), inode (%p), attrs (%p) "
275 "in copy_attributes_from_inode!\n",
282 * We need to be careful to only copy the attributes out of the
283 * iattr object that we know are valid.
286 if (iattr
->ia_valid
& ATTR_UID
) {
287 attrs
->owner
= from_kuid(current_user_ns(), iattr
->ia_uid
);
288 attrs
->mask
|= ORANGEFS_ATTR_SYS_UID
;
289 gossip_debug(GOSSIP_UTILS_DEBUG
, "(UID) %d\n", attrs
->owner
);
291 if (iattr
->ia_valid
& ATTR_GID
) {
292 attrs
->group
= from_kgid(current_user_ns(), iattr
->ia_gid
);
293 attrs
->mask
|= ORANGEFS_ATTR_SYS_GID
;
294 gossip_debug(GOSSIP_UTILS_DEBUG
, "(GID) %d\n", attrs
->group
);
297 if (iattr
->ia_valid
& ATTR_ATIME
) {
298 attrs
->mask
|= ORANGEFS_ATTR_SYS_ATIME
;
299 if (iattr
->ia_valid
& ATTR_ATIME_SET
) {
301 orangefs_convert_time_field(&iattr
->ia_atime
);
302 attrs
->mask
|= ORANGEFS_ATTR_SYS_ATIME_SET
;
305 if (iattr
->ia_valid
& ATTR_MTIME
) {
306 attrs
->mask
|= ORANGEFS_ATTR_SYS_MTIME
;
307 if (iattr
->ia_valid
& ATTR_MTIME_SET
) {
309 orangefs_convert_time_field(&iattr
->ia_mtime
);
310 attrs
->mask
|= ORANGEFS_ATTR_SYS_MTIME_SET
;
313 if (iattr
->ia_valid
& ATTR_CTIME
)
314 attrs
->mask
|= ORANGEFS_ATTR_SYS_CTIME
;
317 * ORANGEFS cannot set size with a setattr operation. Probably not likely
318 * to be requested through the VFS, but just in case, don't worry about
322 if (iattr
->ia_valid
& ATTR_MODE
) {
323 tmp_mode
= iattr
->ia_mode
;
324 if (tmp_mode
& (S_ISVTX
)) {
325 if (is_root_handle(inode
)) {
327 * allow sticky bit to be set on root (since
328 * it shows up that way by default anyhow),
329 * but don't show it to the server
333 gossip_debug(GOSSIP_UTILS_DEBUG
,
334 "User attempted to set sticky bit on non-root directory; returning EINVAL.\n");
339 if (tmp_mode
& (S_ISUID
)) {
340 gossip_debug(GOSSIP_UTILS_DEBUG
,
341 "Attempting to set setuid bit (not supported); returning EINVAL.\n");
345 attrs
->perms
= ORANGEFS_util_translate_mode(tmp_mode
);
346 attrs
->mask
|= ORANGEFS_ATTR_SYS_PERM
;
353 * issues a orangefs getattr request and fills in the appropriate inode
354 * attributes if successful. returns 0 on success; -errno otherwise
356 int orangefs_inode_getattr(struct inode
*inode
, __u32 getattr_mask
)
358 struct orangefs_inode_s
*orangefs_inode
= ORANGEFS_I(inode
);
359 struct orangefs_kernel_op_s
*new_op
;
362 gossip_debug(GOSSIP_UTILS_DEBUG
,
363 "%s: called on inode %pU\n",
365 get_khandle_from_ino(inode
));
367 new_op
= op_alloc(ORANGEFS_VFS_OP_GETATTR
);
370 new_op
->upcall
.req
.getattr
.refn
= orangefs_inode
->refn
;
371 new_op
->upcall
.req
.getattr
.mask
= getattr_mask
;
373 ret
= service_operation(new_op
, __func__
,
374 get_interruptible_flag(inode
));
378 if (copy_attributes_to_inode(inode
,
379 &new_op
->downcall
.resp
.getattr
.attributes
,
380 new_op
->downcall
.resp
.getattr
.link_target
)) {
381 gossip_err("%s: failed to copy attributes\n", __func__
);
387 * Store blksize in orangefs specific part of inode structure; we are
388 * only going to use this to report to stat to make sure it doesn't
389 * perturb any inode related code paths.
391 if (new_op
->downcall
.resp
.getattr
.attributes
.objtype
==
392 ORANGEFS_TYPE_METAFILE
) {
393 orangefs_inode
->blksize
=
394 new_op
->downcall
.resp
.getattr
.attributes
.blksize
;
396 /* mimic behavior of generic_fillattr() for other types. */
397 orangefs_inode
->blksize
= (1 << inode
->i_blkbits
);
402 gossip_debug(GOSSIP_UTILS_DEBUG
,
403 "Getattr on handle %pU, "
404 "fsid %d\n (inode ct = %d) returned %d\n",
405 &orangefs_inode
->refn
.khandle
,
406 orangefs_inode
->refn
.fs_id
,
407 (int)atomic_read(&inode
->i_count
),
415 * issues a orangefs setattr request to make sure the new attribute values
416 * take effect if successful. returns 0 on success; -errno otherwise
418 int orangefs_inode_setattr(struct inode
*inode
, struct iattr
*iattr
)
420 struct orangefs_inode_s
*orangefs_inode
= ORANGEFS_I(inode
);
421 struct orangefs_kernel_op_s
*new_op
;
424 new_op
= op_alloc(ORANGEFS_VFS_OP_SETATTR
);
428 new_op
->upcall
.req
.setattr
.refn
= orangefs_inode
->refn
;
429 ret
= copy_attributes_from_inode(inode
,
430 &new_op
->upcall
.req
.setattr
.attributes
,
437 ret
= service_operation(new_op
, __func__
,
438 get_interruptible_flag(inode
));
440 gossip_debug(GOSSIP_UTILS_DEBUG
,
441 "orangefs_inode_setattr: returning %d\n",
444 /* when request is serviced properly, free req op struct */
448 * successful setattr should clear the atime, mtime and
452 ClearAtimeFlag(orangefs_inode
);
453 ClearMtimeFlag(orangefs_inode
);
454 ClearCtimeFlag(orangefs_inode
);
455 ClearModeFlag(orangefs_inode
);
461 int orangefs_flush_inode(struct inode
*inode
)
464 * If it is a dirty inode, this function gets called.
465 * Gather all the information that needs to be setattr'ed
466 * Right now, this will only be used for mode, atime, mtime
475 struct orangefs_inode_s
*orangefs_inode
= ORANGEFS_I(inode
);
477 memset(&wbattr
, 0, sizeof(wbattr
));
480 * check inode flags up front, and clear them if they are set. This
481 * will prevent multiple processes from all trying to flush the same
482 * inode if they call close() simultaneously
484 mtime_flag
= MtimeFlag(orangefs_inode
);
485 ClearMtimeFlag(orangefs_inode
);
486 ctime_flag
= CtimeFlag(orangefs_inode
);
487 ClearCtimeFlag(orangefs_inode
);
488 atime_flag
= AtimeFlag(orangefs_inode
);
489 ClearAtimeFlag(orangefs_inode
);
490 mode_flag
= ModeFlag(orangefs_inode
);
491 ClearModeFlag(orangefs_inode
);
493 /* -- Lazy atime,mtime and ctime update --
494 * Note: all times are dictated by server in the new scheme
495 * and not by the clients
497 * Also mode updates are being handled now..
501 wbattr
.ia_valid
|= ATTR_MTIME
;
503 wbattr
.ia_valid
|= ATTR_CTIME
;
505 wbattr
.ia_valid
|= ATTR_ATIME
;
508 wbattr
.ia_mode
= inode
->i_mode
;
509 wbattr
.ia_valid
|= ATTR_MODE
;
512 gossip_debug(GOSSIP_UTILS_DEBUG
,
513 "*********** orangefs_flush_inode: %pU "
515 get_khandle_from_ino(inode
),
517 if (wbattr
.ia_valid
== 0) {
518 gossip_debug(GOSSIP_UTILS_DEBUG
,
519 "orangefs_flush_inode skipping setattr()\n");
523 gossip_debug(GOSSIP_UTILS_DEBUG
,
524 "orangefs_flush_inode (%pU) writing mode %o\n",
525 get_khandle_from_ino(inode
),
528 ret
= orangefs_inode_setattr(inode
, &wbattr
);
533 int orangefs_unmount_sb(struct super_block
*sb
)
536 struct orangefs_kernel_op_s
*new_op
= NULL
;
538 gossip_debug(GOSSIP_UTILS_DEBUG
,
539 "orangefs_unmount_sb called on sb %p\n",
542 new_op
= op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT
);
545 new_op
->upcall
.req
.fs_umount
.id
= ORANGEFS_SB(sb
)->id
;
546 new_op
->upcall
.req
.fs_umount
.fs_id
= ORANGEFS_SB(sb
)->fs_id
;
547 strncpy(new_op
->upcall
.req
.fs_umount
.orangefs_config_server
,
548 ORANGEFS_SB(sb
)->devname
,
549 ORANGEFS_MAX_SERVER_ADDR_LEN
);
551 gossip_debug(GOSSIP_UTILS_DEBUG
,
552 "Attempting ORANGEFS Unmount via host %s\n",
553 new_op
->upcall
.req
.fs_umount
.orangefs_config_server
);
555 ret
= service_operation(new_op
, "orangefs_fs_umount", 0);
557 gossip_debug(GOSSIP_UTILS_DEBUG
,
558 "orangefs_unmount: got return value of %d\n", ret
);
562 ORANGEFS_SB(sb
)->mount_pending
= 1;
569 * NOTE: on successful cancellation, be sure to return -EINTR, as
570 * that's the return value the caller expects
572 int orangefs_cancel_op_in_progress(__u64 tag
)
575 struct orangefs_kernel_op_s
*new_op
= NULL
;
577 gossip_debug(GOSSIP_UTILS_DEBUG
,
578 "orangefs_cancel_op_in_progress called on tag %llu\n",
581 new_op
= op_alloc(ORANGEFS_VFS_OP_CANCEL
);
584 new_op
->upcall
.req
.cancel
.op_tag
= tag
;
586 gossip_debug(GOSSIP_UTILS_DEBUG
,
587 "Attempting ORANGEFS operation cancellation of tag %llu\n",
588 llu(new_op
->upcall
.req
.cancel
.op_tag
));
590 ret
= service_operation(new_op
, "orangefs_cancel", ORANGEFS_OP_CANCELLATION
);
592 gossip_debug(GOSSIP_UTILS_DEBUG
,
593 "orangefs_cancel_op_in_progress: got return value of %d\n",
600 void orangefs_op_initialize(struct orangefs_kernel_op_s
*op
)
603 spin_lock(&op
->lock
);
604 op
->io_completed
= 0;
606 op
->upcall
.type
= ORANGEFS_VFS_OP_INVALID
;
607 op
->downcall
.type
= ORANGEFS_VFS_OP_INVALID
;
608 op
->downcall
.status
= -1;
610 op
->op_state
= OP_VFS_STATE_UNKNOWN
;
612 spin_unlock(&op
->lock
);
616 void orangefs_make_bad_inode(struct inode
*inode
)
618 if (is_root_handle(inode
)) {
620 * if this occurs, the pvfs2-client-core was killed but we
621 * can't afford to lose the inode operations and such
622 * associated with the root handle in any case.
624 gossip_debug(GOSSIP_UTILS_DEBUG
,
625 "*** NOT making bad root inode %pU\n",
626 get_khandle_from_ino(inode
));
628 gossip_debug(GOSSIP_UTILS_DEBUG
,
629 "*** making bad inode %pU\n",
630 get_khandle_from_ino(inode
));
631 make_bad_inode(inode
);
635 /* Block all blockable signals... */
636 void orangefs_block_signals(sigset_t
*orig_sigset
)
641 * Initialize all entries in the signal set to the
642 * inverse of the given mask.
644 siginitsetinv(&mask
, sigmask(SIGKILL
));
646 /* Block 'em Danno... */
647 sigprocmask(SIG_BLOCK
, &mask
, orig_sigset
);
650 /* set the signal mask to the given template... */
651 void orangefs_set_signals(sigset_t
*sigset
)
653 sigprocmask(SIG_SETMASK
, sigset
, NULL
);
657 * The following is a very dirty hack that is now a permanent part of the
658 * ORANGEFS protocol. See protocol.h for more error definitions.
661 /* The order matches include/orangefs-types.h in the OrangeFS source. */
662 static int PINT_errno_mapping
[] = {
663 0, EPERM
, ENOENT
, EINTR
, EIO
, ENXIO
, EBADF
, EAGAIN
, ENOMEM
,
664 EFAULT
, EBUSY
, EEXIST
, ENODEV
, ENOTDIR
, EISDIR
, EINVAL
, EMFILE
,
665 EFBIG
, ENOSPC
, EROFS
, EMLINK
, EPIPE
, EDEADLK
, ENAMETOOLONG
,
666 ENOLCK
, ENOSYS
, ENOTEMPTY
, ELOOP
, EWOULDBLOCK
, ENOMSG
, EUNATCH
,
667 EBADR
, EDEADLOCK
, ENODATA
, ETIME
, ENONET
, EREMOTE
, ECOMM
,
668 EPROTO
, EBADMSG
, EOVERFLOW
, ERESTART
, EMSGSIZE
, EPROTOTYPE
,
669 ENOPROTOOPT
, EPROTONOSUPPORT
, EOPNOTSUPP
, EADDRINUSE
,
670 EADDRNOTAVAIL
, ENETDOWN
, ENETUNREACH
, ENETRESET
, ENOBUFS
,
671 ETIMEDOUT
, ECONNREFUSED
, EHOSTDOWN
, EHOSTUNREACH
, EALREADY
,
672 EACCES
, ECONNRESET
, ERANGE
675 int orangefs_normalize_to_errno(__s32 error_code
)
680 if (error_code
== 0) {
683 * This shouldn't ever happen. If it does it should be fixed on the
686 } else if (error_code
> 0) {
687 gossip_err("orangefs: error status receieved.\n");
688 gossip_err("orangefs: assuming error code is inverted.\n");
689 error_code
= -error_code
;
693 * XXX: This is very bad since error codes from ORANGEFS may not be
694 * suitable for return into userspace.
698 * Convert ORANGEFS error values into errno values suitable for return
701 if ((-error_code
) & ORANGEFS_NON_ERRNO_ERROR_BIT
) {
703 (ORANGEFS_ERROR_NUMBER_BITS
|ORANGEFS_NON_ERRNO_ERROR_BIT
|
704 ORANGEFS_ERROR_BIT
)) == ORANGEFS_ECANCEL
) {
706 * cancellation error codes generally correspond to
707 * a timeout from the client's perspective
709 error_code
= -ETIMEDOUT
;
711 /* assume a default error code */
712 gossip_err("orangefs: warning: got error code without errno equivalent: %d.\n", error_code
);
713 error_code
= -EINVAL
;
716 /* Convert ORANGEFS encoded errno values into regular errno values. */
717 } else if ((-error_code
) & ORANGEFS_ERROR_BIT
) {
718 i
= (-error_code
) & ~(ORANGEFS_ERROR_BIT
|ORANGEFS_ERROR_CLASS_BITS
);
719 if (i
< sizeof(PINT_errno_mapping
)/sizeof(*PINT_errno_mapping
))
720 error_code
= -PINT_errno_mapping
[i
];
722 error_code
= -EINVAL
;
725 * Only ORANGEFS protocol error codes should ever come here. Otherwise
726 * there is a bug somewhere.
729 gossip_err("orangefs: orangefs_normalize_to_errno: got error code which is not from ORANGEFS.\n");
735 __s32
ORANGEFS_util_translate_mode(int mode
)
739 static int modes
[NUM_MODES
] = {
740 S_IXOTH
, S_IWOTH
, S_IROTH
,
741 S_IXGRP
, S_IWGRP
, S_IRGRP
,
742 S_IXUSR
, S_IWUSR
, S_IRUSR
,
745 static int orangefs_modes
[NUM_MODES
] = {
746 ORANGEFS_O_EXECUTE
, ORANGEFS_O_WRITE
, ORANGEFS_O_READ
,
747 ORANGEFS_G_EXECUTE
, ORANGEFS_G_WRITE
, ORANGEFS_G_READ
,
748 ORANGEFS_U_EXECUTE
, ORANGEFS_U_WRITE
, ORANGEFS_U_READ
,
749 ORANGEFS_G_SGID
, ORANGEFS_U_SUID
752 for (i
= 0; i
< NUM_MODES
; i
++)
754 ret
|= orangefs_modes
[i
];
761 * After obtaining a string representation of the client's debug
762 * keywords and their associated masks, this function is called to build an
763 * array of these values.
765 int orangefs_prepare_cdm_array(char *debug_array_string
)
769 char *cds_head
= NULL
;
770 char *cds_delimiter
= NULL
;
773 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
776 * figure out how many elements the cdm_array needs.
778 for (i
= 0; i
< strlen(debug_array_string
); i
++)
779 if (debug_array_string
[i
] == '\n')
782 if (!cdm_element_count
) {
783 pr_info("No elements in client debug array string!\n");
788 kzalloc(cdm_element_count
* sizeof(struct client_debug_mask
),
791 pr_info("malloc failed for cdm_array!\n");
796 cds_head
= debug_array_string
;
798 for (i
= 0; i
< cdm_element_count
; i
++) {
799 cds_delimiter
= strchr(cds_head
, '\n');
800 *cds_delimiter
= '\0';
802 keyword_len
= strcspn(cds_head
, " ");
804 cdm_array
[i
].keyword
= kzalloc(keyword_len
+ 1, GFP_KERNEL
);
805 if (!cdm_array
[i
].keyword
) {
812 cdm_array
[i
].keyword
,
813 (unsigned long long *)&(cdm_array
[i
].mask1
),
814 (unsigned long long *)&(cdm_array
[i
].mask2
));
816 if (!strcmp(cdm_array
[i
].keyword
, ORANGEFS_VERBOSE
))
817 client_verbose_index
= i
;
819 if (!strcmp(cdm_array
[i
].keyword
, ORANGEFS_ALL
))
820 client_all_index
= i
;
822 cds_head
= cds_delimiter
+ 1;
825 rc
= cdm_element_count
;
827 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: rc:%d:\n", __func__
, rc
);
836 * /sys/kernel/debug/orangefs/debug-help can be catted to
837 * see all the available kernel and client debug keywords.
839 * When the kernel boots, we have no idea what keywords the
840 * client supports, nor their associated masks.
842 * We pass through this function once at boot and stamp a
843 * boilerplate "we don't know" message for the client in the
844 * debug-help file. We pass through here again when the client
845 * starts and then we can fill out the debug-help file fully.
847 * The client might be restarted any number of times between
848 * reboots, we only build the debug-help file the first time.
850 int orangefs_prepare_debugfs_help_string(int at_boot
)
855 char *client_title
= "Client Debug Keywords:\n";
856 char *kernel_title
= "Kernel Debug Keywords:\n";
858 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
861 byte_count
+= strlen(HELP_STRING_UNINITIALIZED
);
862 client_title
= HELP_STRING_UNINITIALIZED
;
865 * fill the client keyword/mask array and remember
866 * how many elements there were.
869 orangefs_prepare_cdm_array(client_debug_array_string
);
870 if (cdm_element_count
<= 0)
873 /* Count the bytes destined for debug_help_string. */
874 byte_count
+= strlen(client_title
);
876 for (i
= 0; i
< cdm_element_count
; i
++) {
877 byte_count
+= strlen(cdm_array
[i
].keyword
+ 2);
878 if (byte_count
>= DEBUG_HELP_STRING_SIZE
) {
879 pr_info("%s: overflow 1!\n", __func__
);
884 gossip_debug(GOSSIP_UTILS_DEBUG
,
885 "%s: cdm_element_count:%d:\n",
890 byte_count
+= strlen(kernel_title
);
891 for (i
= 0; i
< num_kmod_keyword_mask_map
; i
++) {
893 strlen(s_kmod_keyword_mask_map
[i
].keyword
+ 2);
894 if (byte_count
>= DEBUG_HELP_STRING_SIZE
) {
895 pr_info("%s: overflow 2!\n", __func__
);
900 /* build debug_help_string. */
901 debug_help_string
= kzalloc(DEBUG_HELP_STRING_SIZE
, GFP_KERNEL
);
902 if (!debug_help_string
) {
907 strcat(debug_help_string
, client_title
);
910 for (i
= 0; i
< cdm_element_count
; i
++) {
911 strcat(debug_help_string
, "\t");
912 strcat(debug_help_string
, cdm_array
[i
].keyword
);
913 strcat(debug_help_string
, "\n");
917 strcat(debug_help_string
, "\n");
918 strcat(debug_help_string
, kernel_title
);
920 for (i
= 0; i
< num_kmod_keyword_mask_map
; i
++) {
921 strcat(debug_help_string
, "\t");
922 strcat(debug_help_string
, s_kmod_keyword_mask_map
[i
].keyword
);
923 strcat(debug_help_string
, "\n");
938 void debug_mask_to_string(void *mask
, int type
)
943 int element_count
= 0;
945 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
948 debug_string
= client_debug_string
;
949 element_count
= cdm_element_count
;
951 debug_string
= kernel_debug_string
;
952 element_count
= num_kmod_keyword_mask_map
;
955 memset(debug_string
, 0, ORANGEFS_MAX_DEBUG_STRING_LEN
);
958 * Some keywords, like "all" or "verbose", are amalgams of
959 * numerous other keywords. Make a special check for those
960 * before grinding through the whole mask only to find out
963 if (check_amalgam_keyword(mask
, type
))
966 /* Build the debug string. */
967 for (i
= 0; i
< element_count
; i
++)
969 do_c_string(mask
, i
);
971 do_k_string(mask
, i
);
973 len
= strlen(debug_string
);
976 client_debug_string
[len
- 1] = '\0';
978 kernel_debug_string
[len
- 1] = '\0';
980 strcpy(client_debug_string
, "none");
982 strcpy(kernel_debug_string
, "none");
985 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: string:%s:\n", __func__
, debug_string
);
991 void do_k_string(void *k_mask
, int index
)
993 __u64
*mask
= (__u64
*) k_mask
;
995 if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map
[index
].keyword
))
998 if (*mask
& s_kmod_keyword_mask_map
[index
].mask_val
) {
999 if ((strlen(kernel_debug_string
) +
1000 strlen(s_kmod_keyword_mask_map
[index
].keyword
))
1001 < ORANGEFS_MAX_DEBUG_STRING_LEN
- 1) {
1002 strcat(kernel_debug_string
,
1003 s_kmod_keyword_mask_map
[index
].keyword
);
1004 strcat(kernel_debug_string
, ",");
1006 gossip_err("%s: overflow!\n", __func__
);
1007 strcpy(kernel_debug_string
, ORANGEFS_ALL
);
1017 void do_c_string(void *c_mask
, int index
)
1019 struct client_debug_mask
*mask
= (struct client_debug_mask
*) c_mask
;
1021 if (keyword_is_amalgam(cdm_array
[index
].keyword
))
1024 if ((mask
->mask1
& cdm_array
[index
].mask1
) ||
1025 (mask
->mask2
& cdm_array
[index
].mask2
)) {
1026 if ((strlen(client_debug_string
) +
1027 strlen(cdm_array
[index
].keyword
) + 1)
1028 < ORANGEFS_MAX_DEBUG_STRING_LEN
- 2) {
1029 strcat(client_debug_string
,
1030 cdm_array
[index
].keyword
);
1031 strcat(client_debug_string
, ",");
1033 gossip_err("%s: overflow!\n", __func__
);
1034 strcpy(client_debug_string
, ORANGEFS_ALL
);
1042 int keyword_is_amalgam(char *keyword
)
1046 if ((!strcmp(keyword
, ORANGEFS_ALL
)) || (!strcmp(keyword
, ORANGEFS_VERBOSE
)))
1056 * return 1 if we found an amalgam.
1058 int check_amalgam_keyword(void *mask
, int type
)
1061 struct client_debug_mask
*c_mask
;
1062 int k_all_index
= num_kmod_keyword_mask_map
- 1;
1066 c_mask
= (struct client_debug_mask
*) mask
;
1068 if ((c_mask
->mask1
== cdm_array
[client_all_index
].mask1
) &&
1069 (c_mask
->mask2
== cdm_array
[client_all_index
].mask2
)) {
1070 strcpy(client_debug_string
, ORANGEFS_ALL
);
1075 if ((c_mask
->mask1
== cdm_array
[client_verbose_index
].mask1
) &&
1076 (c_mask
->mask2
== cdm_array
[client_verbose_index
].mask2
)) {
1077 strcpy(client_debug_string
, ORANGEFS_VERBOSE
);
1083 k_mask
= (__u64
*) mask
;
1085 if (*k_mask
>= s_kmod_keyword_mask_map
[k_all_index
].mask_val
) {
1086 strcpy(kernel_debug_string
, ORANGEFS_ALL
);
1101 void debug_string_to_mask(char *debug_string
, void *mask
, int type
)
1103 char *unchecked_keyword
;
1105 char *strsep_fodder
= kstrdup(debug_string
, GFP_KERNEL
);
1106 char *original_pointer
;
1107 int element_count
= 0;
1108 struct client_debug_mask
*c_mask
;
1111 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
1114 c_mask
= (struct client_debug_mask
*)mask
;
1115 element_count
= cdm_element_count
;
1117 k_mask
= (__u64
*)mask
;
1119 element_count
= num_kmod_keyword_mask_map
;
1122 original_pointer
= strsep_fodder
;
1123 while ((unchecked_keyword
= strsep(&strsep_fodder
, ",")))
1124 if (strlen(unchecked_keyword
)) {
1125 for (i
= 0; i
< element_count
; i
++)
1136 kfree(original_pointer
);
1139 void do_c_mask(int i
,
1140 char *unchecked_keyword
,
1141 struct client_debug_mask
**sane_mask
)
1144 if (!strcmp(cdm_array
[i
].keyword
, unchecked_keyword
)) {
1145 (**sane_mask
).mask1
= (**sane_mask
).mask1
| cdm_array
[i
].mask1
;
1146 (**sane_mask
).mask2
= (**sane_mask
).mask2
| cdm_array
[i
].mask2
;
1150 void do_k_mask(int i
, char *unchecked_keyword
, __u64
**sane_mask
)
1153 if (!strcmp(s_kmod_keyword_mask_map
[i
].keyword
, unchecked_keyword
))
1154 **sane_mask
= (**sane_mask
) |
1155 s_kmod_keyword_mask_map
[i
].mask_val
;