Replace CFS_CAP_XXX with kernel standard CAP_XXX flags.
Keep cfs_cap_xxx(raise/lower/raised) wrappers.
Signed-off-by: Liu Xuezhao <xuezhao.liu@emc.com>
Signed-off-by: Peng Tao <tao.peng@emc.com>
Signed-off-by: James Simmons <uja.ornl@gmail.com>
Change-Id: I656c41b94e73bf8d03698a8709be999038a50b35
Reviewed-on: http://review.whamcloud.com/4781
Tested-by: Maloo <whamcloud.maloo@gmail.com>
Tested-by: Hudson
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>
/#[ \t]*define[ \t]*\batomic_sub_return\b *( *\w* *, *\w* *)[ \t]*\batomic_sub_return\b *( *\w* *, *\w* *)/d
s/\bCFS_ATOMIC_INIT\b/ATOMIC_INIT/g
/#[ \t]*define[ \t]*\bATOMIC_INIT\b *( *\w* *)[ \t]*\bATOMIC_INIT\b *( *\w* *)/d
+
+################################################################################
+# CFS_CAP_XXX
+s/\bCFS_CAP_CHOWN\b/CAP_CHOWN/g
+/#[ \t]*define[ \t]*\bCAP_CHOWN\b[ \t]*\bCAP_CHOWN\b/d
+s/\bCFS_CAP_DAC_OVERRIDE\b/CAP_DAC_OVERRIDE/g
+/#[ \t]*define[ \t]*\bCAP_DAC_OVERRIDE\b[ \t]*\bCAP_DAC_OVERRIDE\b/d
+s/\bCFS_CAP_DAC_READ_SEARCH\b/CAP_DAC_READ_SEARCH/g
+/#[ \t]*define[ \t]*\bCAP_DAC_READ_SEARCH\b[ \t]*\bCAP_DAC_READ_SEARCH\b/d
+s/\bCFS_CAP_FOWNER\b/CAP_FOWNER/g
+/#[ \t]*define[ \t]*\bCAP_FOWNER\b[ \t]*\bCAP_FOWNER\b/d
+s/\bCFS_CAP_FSETID\b/CAP_FSETID/g
+/#[ \t]*define[ \t]*\bCAP_FSETID\b[ \t]*\bCAP_FSETID\b/d
+s/\bCFS_CAP_LINUX_IMMUTABLE\b/CAP_LINUX_IMMUTABLE/g
+/#[ \t]*define[ \t]*\bCAP_LINUX_IMMUTABLE\b[ \t]*\bCAP_LINUX_IMMUTABLE\b/d
+s/\bCFS_CAP_SYS_ADMIN\b/CAP_SYS_ADMIN/g
+/#[ \t]*define[ \t]*\bCAP_SYS_ADMIN\b[ \t]*\bCAP_SYS_ADMIN\b/d
+s/\bCFS_CAP_SYS_BOOT\b/CAP_SYS_BOOT/g
+/#[ \t]*define[ \t]*\bCAP_SYS_BOOT\b[ \t]*\bCAP_SYS_BOOT\b/d
+s/\bCFS_CAP_SYS_RESOURCE\b/CAP_SYS_RESOURCE/g
+/#[ \t]*define[ \t]*\bCAP_SYS_RESOURCE\b[ \t]*\bCAP_SYS_RESOURCE\b/d
typedef __u32 cfs_cap_t;
-#define CFS_CAP_CHOWN 0
-#define CFS_CAP_DAC_OVERRIDE 1
-#define CFS_CAP_DAC_READ_SEARCH 2
-#define CFS_CAP_FOWNER 3
-#define CFS_CAP_FSETID 4
-#define CFS_CAP_LINUX_IMMUTABLE 9
-#define CFS_CAP_SYS_ADMIN 21
-#define CFS_CAP_SYS_BOOT 23
-#define CFS_CAP_SYS_RESOURCE 24
-
-#define CFS_CAP_FS_MASK ((1 << CFS_CAP_CHOWN) | \
- (1 << CFS_CAP_DAC_OVERRIDE) | \
- (1 << CFS_CAP_DAC_READ_SEARCH) | \
- (1 << CFS_CAP_FOWNER) | \
- (1 << CFS_CAP_FSETID ) | \
- (1 << CFS_CAP_LINUX_IMMUTABLE) | \
- (1 << CFS_CAP_SYS_ADMIN) | \
- (1 << CFS_CAP_SYS_BOOT) | \
- (1 << CFS_CAP_SYS_RESOURCE))
+#define CFS_CAP_FS_MASK ((1 << CAP_CHOWN) | \
+ (1 << CAP_DAC_OVERRIDE) | \
+ (1 << CAP_DAC_READ_SEARCH) | \
+ (1 << CAP_FOWNER) | \
+ (1 << CAP_FSETID ) | \
+ (1 << CAP_LINUX_IMMUTABLE) | \
+ (1 << CAP_SYS_ADMIN) | \
+ (1 << CAP_SYS_BOOT) | \
+ (1 << CAP_SYS_RESOURCE))
void cfs_cap_raise(cfs_cap_t cap);
void cfs_cap_lower(cfs_cap_t cap);
/* __LIBCFS_CURPROC_H__ */
#endif
-/*
- * Local variables:
- * c-indentation-style: "K&R"
- * c-basic-offset: 8
- * tab-width: 8
- * fill-column: 80
- * scroll-step: 1
- * End:
- */
#error libcfs_register_panic_notifier() missing
#error libcfs_unregister_panic_notifier() missing
+#define CAP_CHOWN 0
+#define CAP_DAC_OVERRIDE 1
+#define CAP_DAC_READ_SEARCH 2
+#define CAP_FOWNER 3
+#define CAP_FSETID 4
+#define CAP_LINUX_IMMUTABLE 9
+#define CAP_SYS_ADMIN 21
+#define CAP_SYS_BOOT 23
+#define CAP_SYS_RESOURCE 24
+
/* --------------------------------------------------------------------- */
#define num_online_cpus() cfs_online_cpus()
#define EXIT_NESTING do {;} while (0)
#define __current_nesting_level() (0)
+#define CAP_CHOWN 0
+#define CAP_DAC_OVERRIDE 1
+#define CAP_DAC_READ_SEARCH 2
+#define CAP_FOWNER 3
+#define CAP_FSETID 4
+#define CAP_LINUX_IMMUTABLE 9
+#define CAP_SYS_ADMIN 21
+#define CAP_SYS_BOOT 23
+#define CAP_SYS_RESOURCE 24
+
/**
* Platform specific declarations for cfs_curproc API (libcfs/curproc.h)
*
#define CFS_SYSFS_MODULE_PARM 0 /* no sysfs access to module parameters */
+#define CAP_CHOWN 0
+#define CAP_DAC_OVERRIDE 1
+#define CAP_DAC_READ_SEARCH 2
+#define CAP_FOWNER 3
+#define CAP_FSETID 4
+#define CAP_LINUX_IMMUTABLE 9
+#define CAP_SYS_ADMIN 21
+#define CAP_SYS_BOOT 23
+#define CAP_SYS_RESOURCE 24
/* winnt panic */
void libcfs_panic(char *msg);
int cfs_capable(cfs_cap_t cap)
{
- return cap == CFS_CAP_SYS_BOOT ? is_suser(): is_suser1();
+ return cap == CAP_SYS_BOOT ? is_suser(): is_suser1();
}
/*
/* Handle platform-dependent IOC requests */
switch (cmd) {
case IOC_LIBCFS_PANIC:
- if (!cfs_capable(CFS_CAP_SYS_BOOT))
+ if (!cfs_capable(CAP_SYS_BOOT))
return (-EPERM);
panic("debugctl-invoked panic");
return (0);
case IOC_LIBCFS_MEMHOG:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
return -EPERM;
/* go thought */
}
* trying to determine the string length, so we're trusting our
* caller... */
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- return (-EPERM);
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ return (-EPERM);
if (user_size > 0 &&
maxsize > user_size)
int i;
int j;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- return (-EPERM);
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ return (-EPERM);
if (!enable) {
LWT_EVENT(0,0,0,0);
int i;
int j;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
return (-EPERM);
*ncpu = num_online_cpus();
/* Handle platform-dependent IOC requests */
switch (cmd) {
case IOC_LIBCFS_PANIC:
- if (!cfs_capable(CFS_CAP_SYS_BOOT))
+ if (!cfs_capable(CAP_SYS_BOOT))
return (-EPERM);
CERROR("debugctl-invoked panic");
KeBugCheckEx('LUFS', (ULONG_PTR)libcfs_ioctl, (ULONG_PTR)NULL, (ULONG_PTR)NULL, (ULONG_PTR)NULL);
return (0);
case IOC_LIBCFS_MEMHOG:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
return -EPERM;
break;
}
int sptlrpc_unpack_user_desc(struct lustre_msg *req, int offset, int swabbed);
-#define CFS_CAP_CHOWN_MASK (1 << CFS_CAP_CHOWN)
-#define CFS_CAP_SYS_RESOURCE_MASK (1 << CFS_CAP_SYS_RESOURCE)
+#define CFS_CAP_CHOWN_MASK (1 << CAP_CHOWN)
+#define CFS_CAP_SYS_RESOURCE_MASK (1 << CAP_SYS_RESOURCE)
enum {
LUSTRE_SEC_NONE = 0,
if ((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask)
return 0;
- if ((mask & (MAY_READ|MAY_WRITE)) ||
- (st->st_mode & S_IXUGO))
- if (cfs_capable(CFS_CAP_DAC_OVERRIDE))
- return 0;
-
- if (mask == MAY_READ ||
- (S_ISDIR(st->st_mode) && !(mask & MAY_WRITE))) {
- if (cfs_capable(CFS_CAP_DAC_READ_SEARCH))
- return 0;
- }
+ if ((mask & (MAY_READ|MAY_WRITE)) ||
+ (st->st_mode & S_IXUGO))
+ if (cfs_capable(CAP_DAC_OVERRIDE))
+ return 0;
+
+ if (mask == MAY_READ ||
+ (S_ISDIR(st->st_mode) && !(mask & MAY_WRITE))) {
+ if (cfs_capable(CAP_DAC_READ_SEARCH))
+ return 0;
+ }
- return -EACCES;
+ return -EACCES;
}
static void llu_fsop_gone(struct filesys *fs)
if (ia_valid & ATTR_MODE) {
st->st_mode = attr->ia_mode;
if (!in_group_p(st->st_gid) &&
- !cfs_capable(CFS_CAP_FSETID))
+ !cfs_capable(CAP_FSETID))
st->st_mode &= ~S_ISGID;
}
/* mark_inode_dirty(inode); */
if (current->fsuid != st->st_uid &&
(rc = ll_permission(inode, MAY_WRITE)) != 0)
RETURN(rc);
- } else {
- /* from inode_change_ok() */
- if (current->fsuid != st->st_uid &&
- !cfs_capable(CFS_CAP_FOWNER))
- RETURN(-EPERM);
- }
- }
+ } else {
+ /* from inode_change_ok() */
+ if (current->fsuid != st->st_uid &&
+ !cfs_capable(CAP_FOWNER))
+ RETURN(-EPERM);
+ }
+ }
/* Won't invoke llu_vmtruncate(), as we already cleared
int rc = 0;
ENTRY;
- switch (cmd) {
- case LUSTRE_Q_INVALIDATE:
- case LUSTRE_Q_FINVALIDATE:
- case Q_QUOTAON:
- case Q_QUOTAOFF:
- case Q_SETQUOTA:
- case Q_SETINFO:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
- sbi->ll_flags & LL_SBI_RMT_CLIENT)
- RETURN(-EPERM);
- break;
+ switch (cmd) {
+ case LUSTRE_Q_INVALIDATE:
+ case LUSTRE_Q_FINVALIDATE:
+ case Q_QUOTAON:
+ case Q_QUOTAOFF:
+ case Q_SETQUOTA:
+ case Q_SETINFO:
+ if (!cfs_capable(CAP_SYS_ADMIN) ||
+ sbi->ll_flags & LL_SBI_RMT_CLIENT)
+ RETURN(-EPERM);
+ break;
case Q_GETQUOTA:
if (((type == USRQUOTA && current_euid() != id) ||
(type == GRPQUOTA && !in_egroup_p(id))) &&
- (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
+ (!cfs_capable(CAP_SYS_ADMIN) ||
sbi->ll_flags & LL_SBI_RMT_CLIENT))
RETURN(-EPERM);
- break;
- case Q_GETINFO:
+ break;
+ case Q_GETINFO:
break;
default:
CERROR("unsupported quotactl op: %#x\n", cmd);
case OBD_IOC_LLOG_CATINFO: {
RETURN(-EOPNOTSUPP);
}
- case OBD_IOC_QUOTACHECK: {
- struct obd_quotactl *oqctl;
- int error = 0;
+ case OBD_IOC_QUOTACHECK: {
+ struct obd_quotactl *oqctl;
+ int error = 0;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
- sbi->ll_flags & LL_SBI_RMT_CLIENT)
- RETURN(-EPERM);
+ if (!cfs_capable(CAP_SYS_ADMIN) ||
+ sbi->ll_flags & LL_SBI_RMT_CLIENT)
+ RETURN(-EPERM);
OBD_ALLOC_PTR(oqctl);
if (!oqctl)
OBD_FREE_PTR(oqctl);
return error ?: rc;
}
- case OBD_IOC_POLL_QUOTACHECK: {
- struct if_quotacheck *check;
+ case OBD_IOC_POLL_QUOTACHECK: {
+ struct if_quotacheck *check;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN) ||
- sbi->ll_flags & LL_SBI_RMT_CLIENT)
- RETURN(-EPERM);
+ if (!cfs_capable(CAP_SYS_ADMIN) ||
+ sbi->ll_flags & LL_SBI_RMT_CLIENT)
+ RETURN(-EPERM);
OBD_ALLOC_PTR(check);
if (!check)
struct ost_id oi;
ENTRY;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
RETURN(-EPERM);
if (copy_from_user(&ucreat, (struct ll_recreate_obj *)arg,
obd_count ost_idx;
ENTRY;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
RETURN(-EPERM);
if (copy_from_user(&fid, (struct lu_fid *)arg, sizeof(fid)))
int rc;
ENTRY;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
RETURN(-EPERM);
OBD_ALLOC_LARGE(lump, lum_size);
int outsize, rc;
ENTRY;
- if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
+ if (!cfs_capable(CAP_DAC_READ_SEARCH) &&
!(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
RETURN(-EPERM);
/* Non-root users are forbidden to set or clear flags which are
* NOT defined in HSM_USER_MASK. */
if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
- !cfs_capable(CFS_CAP_SYS_ADMIN))
+ !cfs_capable(CAP_SYS_ADMIN))
RETURN(-EPERM);
op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
/* POSIX: check before ATTR_*TIME_SET set (from inode_change_ok) */
if (attr->ia_valid & TIMES_SET_FLAGS) {
if (current_fsuid() != inode->i_uid &&
- !cfs_capable(CFS_CAP_FOWNER))
+ !cfs_capable(CAP_FOWNER))
RETURN(-EPERM);
}
static
int xattr_type_filter(struct ll_sb_info *sbi, int xattr_type)
{
- if ((xattr_type == XATTR_ACL_ACCESS_T ||
- xattr_type == XATTR_ACL_DEFAULT_T) &&
- !(sbi->ll_flags & LL_SBI_ACL))
- return -EOPNOTSUPP;
-
- if (xattr_type == XATTR_USER_T && !(sbi->ll_flags & LL_SBI_USER_XATTR))
- return -EOPNOTSUPP;
- if (xattr_type == XATTR_TRUSTED_T && !cfs_capable(CFS_CAP_SYS_ADMIN))
- return -EPERM;
- if (xattr_type == XATTR_OTHER_T)
- return -EOPNOTSUPP;
-
- return 0;
+ if ((xattr_type == XATTR_ACL_ACCESS_T ||
+ xattr_type == XATTR_ACL_DEFAULT_T) &&
+ !(sbi->ll_flags & LL_SBI_ACL))
+ return -EOPNOTSUPP;
+
+ if (xattr_type == XATTR_USER_T && !(sbi->ll_flags & LL_SBI_USER_XATTR))
+ return -EOPNOTSUPP;
+ if (xattr_type == XATTR_TRUSTED_T && !cfs_capable(CAP_SYS_ADMIN))
+ return -EPERM;
+ if (xattr_type == XATTR_OTHER_T)
+ return -EOPNOTSUPP;
+
+ return 0;
}
static
if (tmp_la->la_uid == uc->uc_fsuid)
return 0;
- return !md_capable(uc, CFS_CAP_FOWNER);
+ return !md_capable(uc, CAP_FOWNER);
}
static int mdd_may_delete_entry(const struct lu_env *env,
(LUSTRE_IMMUTABLE_FL | LUSTRE_APPEND_FL);
if ((uc->uc_fsuid != tmp_la->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
/* XXX: the IMMUTABLE and APPEND_ONLY flags can
if (mdd_is_append(obj))
oldflags |= LUSTRE_APPEND_FL;
if ((oldflags ^ newflags) &&
- !md_capable(uc, CFS_CAP_LINUX_IMMUTABLE))
+ !md_capable(uc, CAP_LINUX_IMMUTABLE))
RETURN(-EPERM);
if (!S_ISDIR(tmp_la->la_mode))
if ((la->la_valid & (LA_MTIME | LA_ATIME | LA_CTIME)) &&
!(la->la_valid & ~(LA_MTIME | LA_ATIME | LA_CTIME))) {
if ((uc->uc_fsuid != tmp_la->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER)) {
+ !md_capable(uc, CAP_FOWNER)) {
rc = mdd_permission_internal(env, obj, tmp_la,
MAY_WRITE);
if (rc)
if (la->la_valid & LA_MODE) {
if (!(flags & MDS_PERM_BYPASS) &&
(uc->uc_fsuid != tmp_la->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
if (la->la_mode == (umode_t) -1)
/* Also check the setgid bit! */
if (!lustre_in_group_p(uc, (la->la_valid & LA_GID) ?
la->la_gid : tmp_la->la_gid) &&
- !md_capable(uc, CFS_CAP_FSETID))
+ !md_capable(uc, CAP_FSETID))
la->la_mode &= ~S_ISGID;
} else {
la->la_mode = tmp_la->la_mode;
la->la_uid = tmp_la->la_uid;
if (((uc->uc_fsuid != tmp_la->la_uid) ||
(la->la_uid != tmp_la->la_uid)) &&
- !md_capable(uc, CFS_CAP_CHOWN))
+ !md_capable(uc, CAP_CHOWN))
RETURN(-EPERM);
/* If the user or group of a non-directory has been
if (((uc->uc_fsuid != tmp_la->la_uid) ||
((la->la_gid != tmp_la->la_gid) &&
!lustre_in_group_p(uc, la->la_gid))) &&
- !md_capable(uc, CFS_CAP_CHOWN))
+ !md_capable(uc, CAP_CHOWN))
RETURN(-EPERM);
/* Likewise, if the user or group of a non-directory
RETURN(rc);
if ((uc->uc_fsuid != tmp_la->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
RETURN(rc);
if (uc && ((uc->uc_valid == UCRED_OLD) ||
(uc->uc_valid == UCRED_NEW)) &&
(uc->uc_fsuid != tmp_la->la_uid) &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
RETURN(-EPERM);
}
#endif
check_capabilities:
if (!(mask & MAY_EXEC) ||
(la->la_mode & S_IXUGO) || S_ISDIR(la->la_mode))
- if (md_capable(uc, CFS_CAP_DAC_OVERRIDE))
+ if (md_capable(uc, CAP_DAC_OVERRIDE))
RETURN(0);
if ((mask == MAY_READ) ||
(S_ISDIR(la->la_mode) && !(mask & MAY_WRITE)))
- if (md_capable(uc, CFS_CAP_DAC_READ_SEARCH))
+ if (md_capable(uc, CAP_DAC_READ_SEARCH))
RETURN(0);
RETURN(-EACCES);
uc = lu_ucred_assert(env);
if (la->la_uid != uc->uc_fsuid &&
- !md_capable(uc, CFS_CAP_FOWNER))
+ !md_capable(uc, CAP_FOWNER))
rc = -EPERM;
}
uc = lu_ucred(env);
uc_cap_save = uc->uc_cap;
- uc->uc_cap |= 1 << CFS_CAP_DAC_OVERRIDE;
+ uc->uc_cap |= 1 << CAP_DAC_OVERRIDE;
rc = mdo_create(env, mdt_object_child(local_root), lname,
mdt_object_child(obj), spec, attr);
uc->uc_cap = uc_cap_save;
struct seq_server_site *ss;
struct lu_ucred *uc = mdt_ucred(info);
- if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) {
+ if (!md_capable(uc, CAP_SYS_ADMIN)) {
if (uc->uc_gid !=
mdt->mdt_enable_remote_dir_gid &&
mdt->mdt_enable_remote_dir_gid != -1) {
if (info->mti_spec.sp_rm_entry) {
struct lu_ucred *uc = mdt_ucred(info);
- if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) {
+ if (!md_capable(uc, CAP_SYS_ADMIN)) {
CERROR("%s: unlink remote entry is only "
"permitted for administrator: rc = %d\n",
mdt_obd_name(info->mti_mdt),
static long obd_class_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
- int err = 0;
- ENTRY;
+ int err = 0;
+ ENTRY;
- /* Allow non-root access for OBD_IOC_PING_TARGET - used by lfs check */
- if (!cfs_capable(CFS_CAP_SYS_ADMIN) && (cmd != OBD_IOC_PING_TARGET))
- RETURN(err = -EACCES);
- if ((cmd & 0xffffff00) == ((int)'T') << 8) /* ignore all tty ioctls */
- RETURN(err = -ENOTTY);
+ /* Allow non-root access for OBD_IOC_PING_TARGET - used by lfs check */
+ if (!cfs_capable(CAP_SYS_ADMIN) && (cmd != OBD_IOC_PING_TARGET))
+ RETURN(err = -EACCES);
+ if ((cmd & 0xffffff00) == ((int)'T') << 8) /* ignore all tty ioctls */
+ RETURN(err = -ENOTTY);
- err = class_handle_ioctl(cmd, (unsigned long)arg);
+ err = class_handle_ioctl(cmd, (unsigned long)arg);
- RETURN(err);
+ RETURN(err);
}
/* declare character device */
if (lop->lop_declare_create == NULL)
RETURN(-EOPNOTSUPP);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = lop->lop_declare_create(env, loghandle, th);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
RETURN(rc);
}
EXPORT_SYMBOL(llog_declare_create);
if (lop->lop_create == NULL)
RETURN(-EOPNOTSUPP);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = lop->lop_create(env, handle, th);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
RETURN(rc);
}
EXPORT_SYMBOL(llog_create);
if (lop->lop_declare_write_rec == NULL)
RETURN(-EOPNOTSUPP);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = lop->lop_declare_write_rec(env, handle, rec, idx, th);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
RETURN(rc);
}
EXPORT_SYMBOL(llog_declare_write_rec);
buflen = rec->lrh_len;
LASSERT(cfs_size_round(buflen) == buflen);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = lop->lop_write_rec(env, handle, rec, logcookies, numcookies,
buf, idx, th);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
RETURN(rc);
}
EXPORT_SYMBOL(llog_write_rec);
if (lgh->lgh_logops->lop_add == NULL)
RETURN(-EOPNOTSUPP);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = lgh->lgh_logops->lop_add(env, lgh, rec, logcookies, buf, th);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
RETURN(rc);
}
EXPORT_SYMBOL(llog_add);
if (lgh->lgh_logops->lop_declare_add == NULL)
RETURN(-EOPNOTSUPP);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = lgh->lgh_logops->lop_declare_add(env, lgh, rec, th);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
RETURN(rc);
}
EXPORT_SYMBOL(llog_declare_add);
(*lgh)->lgh_ctxt = ctxt;
(*lgh)->lgh_logops = ctxt->loc_logops;
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = ctxt->loc_logops->lop_open(env, *lgh, logid, name, open_param);
if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
+ cfs_cap_lower(CAP_SYS_RESOURCE);
if (rc) {
llog_free_handle(*lgh);
*lgh = NULL;
RETURN(-ENXIO);
CTXT_CHECK_OP(ctxt, obd_add, -EOPNOTSUPP);
- raised = cfs_cap_raised(CFS_CAP_SYS_RESOURCE);
- if (!raised)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
+ raised = cfs_cap_raised(CAP_SYS_RESOURCE);
+ if (!raised)
+ cfs_cap_raise(CAP_SYS_RESOURCE);
rc = CTXTP(ctxt, obd_add)(env, ctxt, rec, lsm, logcookies,
numcookies);
- if (!raised)
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
- RETURN(rc);
+ if (!raised)
+ cfs_cap_lower(CAP_SYS_RESOURCE);
+ RETURN(rc);
}
EXPORT_SYMBOL(llog_obd_add);
oa->o_mode = attr->ia_mode;
oa->o_valid |= OBD_MD_FLTYPE | OBD_MD_FLMODE;
if (!in_group_p(oa->o_gid) &&
- !cfs_capable(CFS_CAP_FSETID))
+ !cfs_capable(CAP_FSETID))
oa->o_mode &= ~S_ISGID;
}
if (ia_valid & ATTR_UID) {
attr->ia_mode = (attr->ia_mode & S_IFMT)|(oa->o_mode & ~S_IFMT);
attr->ia_valid |= ATTR_MODE;
if (!in_group_p(oa->o_gid) &&
- !cfs_capable(CFS_CAP_FSETID))
+ !cfs_capable(CAP_FSETID))
attr->ia_mode &= ~S_ISGID;
}
if (valid & OBD_MD_FLUID) {
if (rc)
GOTO(out, rc = -ENOMEM);
- switch (cmd) {
- case OBD_IOC_CREATE: /* may create echo object */
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO (out, rc = -EPERM);
+ switch (cmd) {
+ case OBD_IOC_CREATE: /* may create echo object */
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO (out, rc = -EPERM);
- rc = echo_create_object(env, ed, 1, oa, data->ioc_pbuf1,
- data->ioc_plen1, &dummy_oti);
- GOTO(out, rc);
+ rc = echo_create_object(env, ed, 1, oa, data->ioc_pbuf1,
+ data->ioc_plen1, &dummy_oti);
+ GOTO(out, rc);
case OBD_IOC_ECHO_MD: {
int count;
int dirlen;
__u64 id;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!cfs_capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
count = data->ioc_count;
GOTO(out, rc);
}
case OBD_IOC_ECHO_ALLOC_SEQ: {
- struct lu_env *cl_env;
- int refcheck;
- __u64 seq;
- int max_count;
+ struct lu_env *cl_env;
+ int refcheck;
+ __u64 seq;
+ int max_count;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO(out, rc = -EPERM);
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO(out, rc = -EPERM);
- cl_env = cl_env_get(&refcheck);
- if (IS_ERR(cl_env))
+ cl_env = cl_env_get(&refcheck);
+ if (IS_ERR(cl_env))
GOTO(out, rc = PTR_ERR(cl_env));
rc = lu_env_refill_by_tags(cl_env, ECHO_MD_CTX_TAG,
return -EFAULT;
GOTO(out, rc);
}
- case OBD_IOC_DESTROY:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO (out, rc = -EPERM);
+ case OBD_IOC_DESTROY:
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO (out, rc = -EPERM);
- rc = echo_get_object(&eco, ed, oa);
+ rc = echo_get_object(&eco, ed, oa);
if (rc == 0) {
rc = obd_destroy(env, ec->ec_exp, oa, eco->eo_lsm,
&dummy_oti, NULL, NULL);
}
GOTO(out, rc);
- case OBD_IOC_SETATTR:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO (out, rc = -EPERM);
+ case OBD_IOC_SETATTR:
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO (out, rc = -EPERM);
- rc = echo_get_object(&eco, ed, oa);
+ rc = echo_get_object(&eco, ed, oa);
if (rc == 0) {
struct obd_info oinfo = { { { 0 } } };
oinfo.oi_oa = oa;
}
GOTO(out, rc);
- case OBD_IOC_BRW_WRITE:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO (out, rc = -EPERM);
+ case OBD_IOC_BRW_WRITE:
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO (out, rc = -EPERM);
- rw = OBD_BRW_WRITE;
- /* fall through */
+ rw = OBD_BRW_WRITE;
+ /* fall through */
case OBD_IOC_BRW_READ:
rc = echo_client_brw_ioctl(env, rw, exp, data, &dummy_oti);
GOTO(out, rc);
}
GOTO(out, rc);
- case ECHO_IOC_SET_STRIPE:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO (out, rc = -EPERM);
+ case ECHO_IOC_SET_STRIPE:
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO (out, rc = -EPERM);
if (data->ioc_pbuf1 == NULL) { /* unset */
rc = echo_get_object(&eco, ed, oa);
}
GOTO (out, rc);
- case ECHO_IOC_ENQUEUE:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
- GOTO (out, rc = -EPERM);
+ case ECHO_IOC_ENQUEUE:
+ if (!cfs_capable(CAP_SYS_ADMIN))
+ GOTO (out, rc = -EPERM);
rc = echo_client_enqueue(exp, oa,
data->ioc_conn1, /* lock mode */
oap->oap_obj_off = offset;
LASSERT(!(offset & ~CFS_PAGE_MASK));
- if (!client_is_remote(exp) && cfs_capable(CFS_CAP_SYS_RESOURCE))
+ if (!client_is_remote(exp) && cfs_capable(CAP_SYS_RESOURCE))
oap->oap_brw_flags = OBD_BRW_NOQUOTA;
CFS_INIT_LIST_HEAD(&oap->oap_pending_item);
/* Set the OBD_BRW_SRVLOCK before the page is queued. */
brw_flags |= ops->ops_srvlock ? OBD_BRW_SRVLOCK : 0;
if (!client_is_remote(osc_export(osc)) &&
- cfs_capable(CFS_CAP_SYS_RESOURCE)) {
+ cfs_capable(CAP_SYS_RESOURCE)) {
brw_flags |= OBD_BRW_NOQUOTA;
cmd |= OBD_BRW_NOQUOTA;
}
* cl_page_touch() method, that generic cl_io_commit_write() and page
* fault code calls.
*/
- osc_page_touch(env, cl2osc_page(slice), to);
- if (!client_is_remote(osc_export(obj)) &&
- cfs_capable(CFS_CAP_SYS_RESOURCE))
- oap->oap_brw_flags |= OBD_BRW_NOQUOTA;
+ osc_page_touch(env, cl2osc_page(slice), to);
+ if (!client_is_remote(osc_export(obj)) &&
+ cfs_capable(CAP_SYS_RESOURCE))
+ oap->oap_brw_flags |= OBD_BRW_NOQUOTA;
if (oio->oi_lockless)
/* see osc_io_prepare_write() for lockless io handling. */
oap->oap_brw_flags = OBD_BRW_SYNC | brw_flags;
if (!client_is_remote(osc_export(obj)) &&
- cfs_capable(CFS_CAP_SYS_RESOURCE)) {
+ cfs_capable(CAP_SYS_RESOURCE)) {
oap->oap_brw_flags |= OBD_BRW_NOQUOTA;
oap->oap_cmd |= OBD_BRW_NOQUOTA;
}