Ocfs2: Add new OCFS2_IOC_INFO ioctl for ocfs2 v7.
PATCH 1/1 Ocfs2: Add new OCFS2_IOC_INFO ioctl for ocfs2 v7.
The reason why we need this ioctl is to offer the none-privileged end-user a possibility to get filesys info gathering.
We use OCFS2_IOC_INFO to manipulate the new ioctl, userspace passes a structure to kernel containing an array of request pointers and request count, such as,
* From userspace:
struct ocfs2_info_blocksize oib = {
.ib_req = {
.ir_magic = OCFS2_INFO_MAGIC,
.ir_code = OCFS2_INFO_BLOCKSIZE,
...
}
...
}struct ocfs2_info_clustersize oic = {
...
}uint64_t reqs[2] = {(unsigned long)&oib,
(unsigned long)&oic};
struct ocfs2_info info = {
.oi_requests = reqs,
.oi_count = 2,
}
ret = ioctl(fd, OCFS2_IOC_INFO, &info);
* In kernel:
Get the request pointers from *info*, then handle each request one bye one.
Idea here is to make the spearated request small enough to guarantee a better backward&forward compatibility since a small piece of request would be less likely to be broken if filesys on raw disk get changed.
Currently, following 8 ioctls get implemented per the requirement from userspace tool o2info, and I believe it will grow over time:-)
OCFS2_INFO_CLUSTERSIZE
OCFS2_INFO_BLOCKSIZE
OCFS2_INFO_MAXSLOTS
OCFS2_INFO_LABEL
OCFS2_INFO_UUID
OCFS2_INFO_FS_FEATURES
OCFS2_INFO_JOURNAL_SIZE
This ioctl is only specific to OCFS2.
--- fs/ocfs2/ioctl.c | 325 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/ocfs2/ocfs2_ioctl.h | 90 +++++++++++++ 2 files changed, 415 insertions(+), 0 deletions(-)
fs/ocfs2/ioctl.c +325 -0
@@ -23,8 +23,18 @@#include "ioctl.h" #include "resize.h" #include "refcounttree.h" +#include "sysfile.h" +#include "buffer_head_io.h" +#include "suballoc.h" +#include <linux/ext2_fs.h> +#include <linux/compat.h> + +#define o2info_from_user (a, b) \ + copy_from_user(&(a), (b), sizeof(a)) +#define o2info_to_user (a, b) \ + copy_to_user((typeof(a) __user *)b, &(a), sizeof(a))static int ocfs2_get_inode_attr (struct inode *inode,unsigned *flags) {
@@ -109,6 +119,307 @@ bail:return status; } +int ocfs2_info_handle_blocksize (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_blocksize oib; + +if (o2info_from_user (oib, req)) + goto bail; + + oib.ib_blocksize = inode->i_sb->s_blocksize; + oib.ib_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oib, req)) + goto bail; + + status =0 ; +bail: +if (status) + oib.ib_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_clustersize (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_clustersize oic; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (o2info_from_user (oic, req)) + goto bail; + + oic.ic_clustersize = osb->s_clustersize; + oic.ic_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oic, req)) + goto bail; + + status =0 ; +bail: +if (status) + oic.ic_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_maxslots (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_maxslots oim; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (o2info_from_user (oim, req)) + goto bail; + + oim.im_max_slots = osb->max_slots; + oim.im_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oim, req)) + goto bail; + + status =0 ; +bail: +if (status) + oim.im_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_label (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_label oil; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (o2info_from_user (oil, req)) + goto bail; + +memcpy (oil.il_label, osb->vol_label,OCFS2_MAX_VOL_LABEL_LEN ); + oil.il_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oil, req)) + goto bail; + + status =0 ; +bail: +if (status) + oil.il_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_uuid (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_uuid oiu; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (o2info_from_user (oiu, req)) + goto bail; + +memcpy (oiu.iu_uuid_str, osb->uuid_str,OCFS2_TEXT_UUID_LEN +1 ); + oiu.iu_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oiu, req)) + goto bail; + + status =0 ; +bail: +if (status) + oiu.iu_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_fs_features (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_fs_features oif; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (o2info_from_user (oif, req)) + goto bail; + + oif.if_compat_features = osb->s_feature_compat; + oif.if_incompat_features = osb->s_feature_incompat; + oif.if_ro_compat_features = osb->s_feature_ro_compat; + oif.if_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oif, req)) + goto bail; + + status =0 ; +bail: +if (status) + oif.if_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_journal_size (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_journal_size oij; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (o2info_from_user (oij, req)) + goto bail; + + oij.ij_journal_size = osb->journal->j_inode->i_size; + + oij.ij_req.ir_flags |=OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oij, req)) + goto bail; + + status =0 ; +bail: +if (status) + oij.ij_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +int ocfs2_info_handle_unknown (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_request oir; + +if (o2info_from_user (oir, req)) + goto bail; + + oir.ir_flags &= ~OCFS2_INFO_FL_FILLED ; + +if (o2info_to_user (oir, req)) + goto bail; + + status =0 ; +bail: +if (status) + oir.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +} + +/* +* Validate and distinguish OCFS2_IOC_INFO requests. +* +* - validate the magic number. +* - distinguish different requests. +* - validate size of different requests. +*/ +int ocfs2_info_handle_request (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_request oir; + +if (o2info_from_user (oir, req)) + goto bail; + + status = -EINVAL ; +if (oir.ir_magic !=OCFS2_INFO_MAGIC ) + goto bail; + +switch (oir.ir_code) { +case OCFS2_INFO_BLOCKSIZE : +if (oir.ir_size ==sizeof (struct ocfs2_info_blocksize )) + status =ocfs2_info_handle_blocksize (inode, req); +break ; +case OCFS2_INFO_CLUSTERSIZE : +if (oir.ir_size ==sizeof (struct ocfs2_info_clustersize )) + status =ocfs2_info_handle_clustersize (inode, req); +break ; +case OCFS2_INFO_MAXSLOTS : +if (oir.ir_size ==sizeof (struct ocfs2_info_maxslots )) + status =ocfs2_info_handle_maxslots (inode, req); +break ; +case OCFS2_INFO_LABEL : +if (oir.ir_size ==sizeof (struct ocfs2_info_label )) + status =ocfs2_info_handle_label (inode, req); +break ; +case OCFS2_INFO_UUID : +if (oir.ir_size ==sizeof (struct ocfs2_info_uuid )) + status =ocfs2_info_handle_uuid (inode, req); +break ; +case OCFS2_INFO_FS_FEATURES : +if (oir.ir_size ==sizeof (struct ocfs2_info_fs_features )) + status =ocfs2_info_handle_fs_features (inode, req); +break ; +case OCFS2_INFO_JOURNAL_SIZE : +if (oir.ir_size ==sizeof (struct ocfs2_info_journal_size )) + status =ocfs2_info_handle_journal_size (inode, req); +break ; +default : + status =ocfs2_info_handle_unknown (inode, req); +break ; + } + +bail: +return status; +} + +/* +* OCFS2_IOC_INFO handles an array of requests passed from userspace. +* +* ocfs2_info_handle() recevies a large info aggregation, grab and +* validate the request count from header, then break it into small +* pieces, later specific handlers can handle them one by one. +* +* Idea here is to make each separate request small enough to ensure +* a better backward&forward compatibility, since a small piece of +* request will be less likely to be broken if disk layout get changed. +*/ +int ocfs2_info_handle (struct inode *inode,struct ocfs2_info *info, +int compat_flag) +{ +int i, status =0 ; +u64 req_addr; +struct ocfs2_info_request __user *reqp; + +if ((info->oi_count >OCFS2_INFO_MAX_REQUEST ) || + (!info->oi_requests)) { + status = -EINVAL ; + goto bail; + } + +for (i =0 ; i < info->oi_count; i++) { + status = -EFAULT ; +if (compat_flag) { +if (get_user (req_addr, + (u64 __user *)compat_ptr (info->oi_requests) + i)) + goto bail; + }else { +if (get_user (req_addr, + (u64 __user *)(info->oi_requests) + i)) + goto bail; + } + + reqp = (struct ocfs2_info_request *)req_addr; +if (!reqp) { + status = -EINVAL ; + goto bail; + } + + status =ocfs2_info_handle_request (inode, reqp); +if (status) + goto bail; + } + +bail: +return status; +} +long ocfs2_ioctl (struct file *filp,unsigned int cmd,unsigned long arg) {struct inode *inode = filp->f_path.dentry->d_inode;
@@ -120,6 +431,7 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)struct reflink_arguments args;const char *old_path, *new_path;bool preserve; +struct ocfs2_info info;switch (cmd) {case OCFS2_IOC_GETFLAGS :
@@ -174,6 +486,12 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) preserve = (args.preserve !=0 );return ocfs2_reflink_ioctl (inode, old_path, new_path, preserve); +case OCFS2_IOC_INFO : +if (copy_from_user (&info, (struct ocfs2_info __user *)arg, +sizeof (struct ocfs2_info ))) +return -EFAULT ; + +return ocfs2_info_handle (inode, &info,0 );default :return -ENOTTY ; }
@@ -185,6 +503,7 @@ long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)bool preserve;struct reflink_arguments args;struct inode *inode = file->f_path.dentry->d_inode; +struct ocfs2_info info;switch (cmd) {case OCFS2_IOC32_GETFLAGS :
@@ -209,6 +528,12 @@ long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)return ocfs2_reflink_ioctl (inode,compat_ptr (args.old_path),compat_ptr (args.new_path), preserve); +case OCFS2_IOC_INFO : +if (copy_from_user (&info, (struct ocfs2_info __user *)arg, +sizeof (struct ocfs2_info ))) +return -EFAULT ; + +return ocfs2_info_handle (inode, &info,1 );default :return -ENOIOCTLCMD ; }
fs/ocfs2/ocfs2_ioctl.h +90 -0
94 lines not on this page · raw message
Signature · 1 line
1.5.5
PATCH 1/1 Ocfs2: Add new OCFS2_IOC_INFO ioctl for ocfs2 v7.
Quoted 2 lines · Tristan Ye
Currently, following 8 ioctls get implemented per the requirement from userspace tool o2info, and I believe it will grow over time:-)
"Currently, the following 8 requests are supported ..."
Quoted 12 lines
fs/ocfs2/ioctl.c +12
-0+int ocfs2_info_handle_blocksize (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_blocksize oib; + +if (o2info_from_user (oib, req)) + goto bail; + + oib.ib_blocksize = inode->i_sb->s_blocksize; + oib.ib_req.ir_flags |=OCFS2_INFO_FL_FILLED ; +
fs/ocfs2/ioctl.c bail: · line 143
Quoted 10 lines
fs/ocfs2/ioctl.c +10
-0+if (o2info_to_user (oib, req)) + goto bail; + + status =0 ; +bail: +if (status) + oib.ib_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +}
You need to send that FL_ERROR to userspace. Setting it onir_flags doesn't show up in userspace unless you copy it over. I realize that you've already failed the copy to user, but you need to retry it and ignore the error code. Like so:
---------------------------------------------
/*
* This call is void because we are already reporting an error that may
* be -EFAULT. The error will be returned from the ioctl(2) call. It's
* just a best-effort to tell userspace that this request caused the error. */
static inline void __o2info_error_to_user(struct ocfs2_info_request *kreq,
struct ocfs2_info_request __user *req)
{
kreq->ir_flags |= OCFS2_INFO_FL_ERROR;
(void)o2info_to_user(kreq, req);
}#define o2info_error_to_user(a, b) \
__o2info_error_to_user((struct ocfs2_info_request *)&(a), &(b))---------------------------------------------
Now all of the handling functions can say:
bail:
if (status) o2info_error_to_user(oib, req);
Quoted 36 lines
fs/ocfs2/ioctl.c +36
-0+/* +* OCFS2_IOC_INFO handles an array of requests passed from userspace. +* +* ocfs2_info_handle() recevies a large info aggregation, grab and +* validate the request count from header, then break it into small +* pieces, later specific handlers can handle them one by one. +* +* Idea here is to make each separate request small enough to ensure +* a better backward&forward compatibility, since a small piece of +* request will be less likely to be broken if disk layout get changed. +*/ +int ocfs2_info_handle (struct inode *inode,struct ocfs2_info *info, +int compat_flag) +{ +int i, status =0 ; +u64 req_addr; +struct ocfs2_info_request __user *reqp; + +if ((info->oi_count >OCFS2_INFO_MAX_REQUEST ) || + (!info->oi_requests)) { + status = -EINVAL ; + goto bail; + } + +for (i =0 ; i < info->oi_count; i++) { + status = -EFAULT ; +if (compat_flag) { +if (get_user (req_addr, + (u64 __user *)compat_ptr (info->oi_requests) + i)) + goto bail; + }else { +if (get_user (req_addr, + (u64 __user *)(info->oi_requests) + i)) + goto bail; + } +
fs/ocfs2/ioctl.c bail: · line 417
Quoted 10 lines
fs/ocfs2/ioctl.c +10
-0+ reqp = (struct ocfs2_info_request *)req_addr; +if (!reqp) { + status = -EINVAL ; + goto bail; + } + + status =ocfs2_info_handle_request (inode, reqp); +if (status) + goto bail; + }
There is no need to 'goto bail' in the for loop. Just 'break'.
fs/ocfs2/ioctl.c bail: · line 144
Quoted 5 lines
fs/ocfs2/ioctl.c +5
-0+ +bail: +return status; +} +
Joel
Signature · 8 lines
"Get right to the heart of matters. It's the heart that matters more." Joel Becker Principal Software Developer Oracle E-mail: joel.becker at oracle.com Phone: (650) 506-8127
PATCH 1/1 Ocfs2: Add new OCFS2_IOC_INFO ioctl for ocfs2 v7.
Quoted 41 lines · Joel Becker
Quoted 2 lines · Tristan Ye
Currently, following 8 ioctls get implemented per the requirement from userspace tool o2info, and I believe it will grow over time:-)
"Currently, the following 8 requests are supported ..."
Quoted 12 lines
fs/ocfs2/ioctl.c +12
-0+int ocfs2_info_handle_blocksize (struct inode *inode, +struct ocfs2_info_request __user *req) +{ +int status = -EFAULT ; +struct ocfs2_info_blocksize oib; + +if (o2info_from_user (oib, req)) + goto bail; + + oib.ib_blocksize = inode->i_sb->s_blocksize; + oib.ib_req.ir_flags |=OCFS2_INFO_FL_FILLED ; +fs/ocfs2/ioctl.c bail: · line 143
Quoted 10 lines
fs/ocfs2/ioctl.c +10
-0+if (o2info_to_user (oib, req)) + goto bail; + + status =0 ; +bail: +if (status) + oib.ib_req.ir_flags |=OCFS2_INFO_FL_ERROR ; + +return status; +}You need to send that
FL_ERRORto userspace. Setting it onir_flagsdoesn't show up in userspace unless you copy it over. I realize that you've already failed the copy to user, but you need to retry it and ignore the error code. Like so:---------------------------------------------
/*
* This call is void because we are already reporting an error that may
* be-EFAULT. The error will be returned from the ioctl(2) call. It's
* just a best-effort to tell userspace that this request caused the error. */
static inline void __o2info_error_to_user(structocfs2_info_request*kreq,
structocfs2_info_request__user*req)
Quoted 3 lines
{
kreq->ir_flags |= OCFS2_INFO_FL_ERROR;
(void)o2info_to_user(kreq, req);Joel,
I thought we'd better not pass the whole ocfs2_info_request body this time, but passing only ir_flags instead.
kreq->ir_flags |= OCFS2_INFO_FL_ERROR;
put_user(kreq->ir_flags, (__u32 user *)&(req->ir_flags));
There may be two reasons:
1. copy_to_user(kreq, req) is an overkill when compared to put_user(kflags, flags).
2. we're more likely to hit -EFAULT again when passing the whole request body, sending ir_flags ONLY to userpace reduce such risk.
Another corner:
How about if we hit -EFAULT again when sending the FL_ERROR to userpsace? actually I guess it's quite likely to happen since we've had already failed to pass the request body last time.
Tristan.
Quoted 69 lines
}
#define o2info_error_to_user(a, b) \ __o2info_error_to_user((struct ocfs2_info_request *)&(a), &(b))---------------------------------------------
Now all of the handling functions can say:
bail:
if (status) o2info_error_to_user(oib, req);Quoted 36 lines
fs/ocfs2/ioctl.c +36
-0+/* +* OCFS2_IOC_INFO handles an array of requests passed from userspace. +* +* ocfs2_info_handle() recevies a large info aggregation, grab and +* validate the request count from header, then break it into small +* pieces, later specific handlers can handle them one by one. +* +* Idea here is to make each separate request small enough to ensure +* a better backward&forward compatibility, since a small piece of +* request will be less likely to be broken if disk layout get changed. +*/ +int ocfs2_info_handle (struct inode *inode,struct ocfs2_info *info, +int compat_flag) +{ +int i, status =0 ; +u64 req_addr; +struct ocfs2_info_request __user *reqp; + +if ((info->oi_count >OCFS2_INFO_MAX_REQUEST ) || + (!info->oi_requests)) { + status = -EINVAL ; + goto bail; + } + +for (i =0 ; i < info->oi_count; i++) { + status = -EFAULT ; +if (compat_flag) { +if (get_user (req_addr, + (u64 __user *)compat_ptr (info->oi_requests) + i)) + goto bail; + }else { +if (get_user (req_addr, + (u64 __user *)(info->oi_requests) + i)) + goto bail; + } +fs/ocfs2/ioctl.c bail: · line 417
Quoted 10 lines
fs/ocfs2/ioctl.c +10
-0+ reqp = (struct ocfs2_info_request *)req_addr; +if (!reqp) { + status = -EINVAL ; + goto bail; + } + + status =ocfs2_info_handle_request (inode, reqp); +if (status) + goto bail; + }There is no need to 'goto bail' in the for loop. Just 'break'.
fs/ocfs2/ioctl.c bail: · line 144
Quoted 5 lines
fs/ocfs2/ioctl.c +5
-0+ +bail: +return status; +} +Joel
PATCH 1/1 Ocfs2: Add new OCFS2_IOC_INFO ioctl for ocfs2 v7.
Quoted 7 lines · tristan
Quoted 5 lines · Joel Becker
static inline void __o2info_error_to_user(struct
ocfs2_info_request*kreq,
structocfs2_info_request__user*req){ kreq->ir_flags |= OCFS2_INFO_FL_ERROR; (void)o2info_to_user(kreq, req);
Quoted 6 lines
I thought we'd better not pass the whole
ocfs2_info_requestbody this time, but passing onlyir_flagsinstead.
kreq->ir_flags|=OCFS2_INFO_FL_ERROR;
put_user(kreq->ir_flags, (__u32 user *)&(req->ir_flags));
Yep, this is better. As you say, the full copy is overkill.
Quoted 5 lines
Another corner:
How about if we hit
-EFAULTagain when sending theFL_ERRORto userpsace? actually I guess it's quite likely to happen since we've had already failed to pass the request body last time.
I expect we might. We just ignore that error. The user is
still going to get the error code back via the return code of ioctl(). Essentially it's just a best effort. If we got -EFAULT on the entire copy, maybe the put_user() works, maybe it doesn't. Gives the user a chance to check.
Joel
Signature · 10 lines
"We will have to repent in this generation not merely for the vitriolic words and actions of the bad people, but for the appalling silence of the good people." - Rev. Dr. Martin Luther King, Jr. Joel Becker Principal Software Developer Oracle E-mail: joel.becker at oracle.com Phone: (650) 506-8127