Ocfs2: Adding new codes 'OCFS2_INFO_FREEINODE' and 'OCFS2_INFO_FREEFRAG' for o2info ioctl V2.

It's a best-effort attempt to simplize duplicated codes here.

Signed-off-by Tristan Ye <[email protected]>

---
 fs/ocfs2/ioctl.c |   38 ++++++++++++++++++++++++++++++--------
 1 files changed, 30 insertions(+), 8 deletions(-)

fs/ocfs2/ioctl.c +0 -0

index 7a48681..731cf46 100644

Quoted 5 lines

fs/ocfs2/ioctl.c +5 -0

+static inline void __o2info_set_request_filled(struct ocfs2_info_request *req)
+{
+	req->ir_flags |= OCFS2_INFO_FL_FILLED;
+}
+

fs/ocfs2/ioctl.c static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, · line 55

Quoted 2 lines

fs/ocfs2/ioctl.c +2 -0

+#define o2info_set_request_filled(a) \
+		__o2info_set_request_filled((struct ocfs2_info_request *)&(a))

The macro here (and below) casts it's argument, thus defeating any typechecking we would have gotten from the function call. Can you pleaseremove the macro, rename the functions (take out the __) and use them directly? I know we might then want to deref the i*_req field in the handlers below but I don't think that's a big deal for what we gain.

Quoted 5 lines · Mark Fasheh

Quoted 5 lines

fs/ocfs2/ioctl.c +5 -0

+static inline void __o2info_set_request_filled(struct ocfs2_info_request *req)
+{
+	req->ir_flags |= OCFS2_INFO_FL_FILLED;
+}
+

Quoted 8 lines

fs/ocfs2/ioctl.c static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, · line 55

Quoted 2 lines

fs/ocfs2/ioctl.c +2 -0

+#define o2info_set_request_filled(a) \
+		__o2info_set_request_filled((struct ocfs2_info_request *)&(a))

The macro here (and below) casts it's argument, thus defeating any typechecking we would have gotten from the function call. Can you pleaseremove the macro, rename the functions (take out the __) and use them directly? I know we might then want to deref the i*_req field in the handlers below but I don't think that's a big deal for what we gain.

I'm not sure what you mean here. Are you asking for one
set_request_filled() call per info type?

Quoted 15 lines · Joel Becker

Quoted 5 lines · Mark Fasheh

Quoted 5 lines

fs/ocfs2/ioctl.c +5 -0

+static inline void __o2info_set_request_filled(struct ocfs2_info_request *req)
+{
+	req->ir_flags |= OCFS2_INFO_FL_FILLED;
+}
+

Quoted 8 lines

fs/ocfs2/ioctl.c static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, · line 55

Quoted 2 lines

fs/ocfs2/ioctl.c +2 -0

+#define o2info_set_request_filled(a) \
+		__o2info_set_request_filled((struct ocfs2_info_request *)&(a))

The macro here (and below) casts it's argument, thus defeating any typechecking we would have gotten from the function call. Can you pleaseremove the macro, rename the functions (take out the __) and use them directly? I know we might then want to deref the i*_req field in the handlers below but I don't think that's a big deal for what we gain.

Quoted 2 lines

I'm not sure what you mean here. Are you asking for one
set_request_filled() call per info type?

Oh, no!

I was asking for this:

static inline void o2info_set_request_filled(struct ocfs2_info_request *req)

{
	req->ir_flags |= OCFS2_INFO_FL_FILLED;
}

instead of the macro which is defeating type checking.

Quoted 18 lines · Mark Fasheh

Quoted 13 lines · Joel Becker

Quoted 4 lines · Mark Fasheh

Quoted 4 lines

fs/ocfs2/ioctl.c +4 -0

+static inline void __o2info_set_request_filled(struct ocfs2_info_request *req)
+{
+	req->ir_flags |= OCFS2_INFO_FL_FILLED;
+}

Quoted 8 lines

fs/ocfs2/ioctl.c static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, · line 55

Quoted 3 lines

fs/ocfs2/ioctl.c +3 -0

+
+#define o2info_set_request_filled(a) \
+		__o2info_set_request_filled((struct ocfs2_info_request *)&(a))

The macro here (and below) casts it's argument, thus defeating any typechecking we would have gotten from the function call. Can you pleaseremove the macro, rename the functions (take out the __) and use them directly? I know we might then want to deref the i*_req field in the handlers below but I don't think that's a big deal for what we gain.

Quoted 2 lines

I'm not sure what you mean here. Are you asking for one
set_request_filled() call per info type?

Oh, no!

Quoted 8 lines

I was asking for this:

static inline void o2info_set_request_filled(struct ocfs2_info_request *req)

{
	req->ir_flags |= OCFS2_INFO_FL_FILLED;
}

instead of the macro which is defeating type checking.

	You want the casts or derefs forced in the caller, then?

	o2info_set_request_filled((struct ocfs2_info_request *)ic);

or:

	o2info_set_request_filled(&ic->ic_req);

Joel

Quoted 21 lines · Mark Fasheh

Quoted 15 lines · Joel Becker

Quoted 5 lines · Mark Fasheh

Quoted 5 lines

fs/ocfs2/ioctl.c +5 -0

+static inline void __o2info_set_request_filled(struct ocfs2_info_request *req)
+{
+	req->ir_flags |= OCFS2_INFO_FL_FILLED;
+}
+

Quoted 8 lines

fs/ocfs2/ioctl.c static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, · line 55

Quoted 2 lines

fs/ocfs2/ioctl.c +2 -0

+#define o2info_set_request_filled(a) \
+		__o2info_set_request_filled((struct ocfs2_info_request *)&(a))

The macro here (and below) casts it's argument, thus defeating any typechecking we would have gotten from the function call. Can you pleaseremove the macro, rename the functions (take out the __) and use them directly? I know we might then want to deref the i*_req field in the handlers below but I don't think that's a big deal for what we gain.

Quoted 2 lines

I'm not sure what you mean here. Are you asking for one
set_request_filled() call per info type?

Oh, no!

Quoted 8 lines

I was asking for this:

static inline void o2info_set_request_filled(struct ocfs2_info_request *req)

{
	req->ir_flags |= OCFS2_INFO_FL_FILLED;
}

instead of the macro which is defeating type checking.

	You want the casts or derefs forced in the caller, then?

	o2info_set_request_filled((struct ocfs2_info_request *)ic);

or:

	o2info_set_request_filled(&ic->ic_req);

Quoted 1 line · Tristan Ye

It's a best-effort attempt to simplize duplicated codes here.

Nice cleanup. I have only one issue with it:

Quoted 13 lines

Signed-off-by Tristan Ye <[email protected]>

---
 fs/ocfs2/ioctl.c |   38 ++++++++++++++++++++++++++++++--------
 1 files changed, 30 insertions(+), 8 deletions(-)

fs/ocfs2/ioctl.c +0 -0

index 7a48681..731cf46 100644
@@ -46,6 +46,22 @@ static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq,
 #define o2info_set_request_error(a, b) \
 		__o2info_set_request_error((struct ocfs2_info_request *)&(a), b)
 

fs/ocfs2/ioctl.c static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, · line 55

Quoted 7 lines

fs/ocfs2/ioctl.c +7 -0

+static inline void __o2info_set_request_filled(struct ocfs2_info_request *req)
+{
+	req->ir_flags |= OCFS2_INFO_FL_FILLED;
+}
+
+#define o2info_set_request_filled(a) \
+		__o2info_set_request_filled((struct ocfs2_info_request *)&(a))

The macro here (and below) casts it's argument, thus defeating any typechecking we would have gotten from the function call. Can you pleaseremove the macro, rename the functions (take out the __) and use them directly? I know we might then want to deref the i*_req field in the handlers below but I don't think that's a big deal for what we gain.

	--Mark

--
Mark Fasheh

It's a best-effort attempt to simplize duplicated codes here.

Signed-off-by Tristan Ye <[email protected]>

The new code is dedicated to calculate free inodes number of all inode_allocs, then return the info to userpace in terms of an array.

Specially, flag 'OCFS2_INFO_FL_NON_COHERENT', manipulated by '--cluster-coherent' from userspace, is now going to be involved. setting the flag on means no cluster coherency considered, usually, userspace tools choose none-coherency strategy by default for the sake of performace.

Signed-off-by Tristan Ye <[email protected]>

---
 fs/ocfs2/ioctl.c       |  122 ++++++++++++++++++++++++++++++++++++++++++++++++
 fs/ocfs2/ocfs2_ioctl.h |   11 ++++
 2 files changed, 133 insertions(+), 0 deletions(-)

fs/ocfs2/ioctl.c +3 -0

index 731cf46..18812be 100644
@@ -23,6 +23,9 @@
 #include "ioctl.h"
 #include "resize.h"
 #include "refcounttree.h"
+#include "sysfile.h"
+#include "dir.h"
+#include "buffer_head_io.h"
 
 #include <linux/ext2_fs.h>
 

fs/ocfs2/ioctl.c +34 -0

 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
 {
 	int status;

@@ -321,6 +331,114 @@ bail:
 	return status;
 }
 
+int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb,
+				struct inode *inode_alloc, u64 blkno,
+				struct ocfs2_info_freeinode *fi, u32 slot)
+{
+	int status = 0, unlock = 0;
+
+	struct buffer_head *bh = NULL;
+	struct ocfs2_dinode *dinode_alloc = NULL;
+
+	if (inode_alloc)
+		mutex_lock(&inode_alloc->i_mutex);
+
+	if (o2info_coherent(*fi)) {
+		status = ocfs2_inode_lock(inode_alloc, &bh, 0);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+		unlock = 1;
+	} else {
+		status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+	}
+
+	dinode_alloc = (struct ocfs2_dinode *)bh->b_data;
+
+	fi->ifi_stat[slot].lfi_total =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total);
+	fi->ifi_stat[slot].lfi_free =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) -
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_used);

fs/ocfs2/ioctl.c +37 -0

+
+	brelse(bh);
+
+	mlog_exit(status);
+	return status;
+}
+
+int ocfs2_info_handle_freeinode(struct inode *inode,
+				struct ocfs2_info_request __user *req)
+{
+	u32 i;
+	u64 blkno = -1;
+	char namebuf[40];
+	int status = -EFAULT, type = INODE_ALLOC_SYSTEM_INODE;
+	struct ocfs2_info_freeinode oifi;
+	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+	struct inode *inode_alloc = NULL;
+
+	if (o2info_from_user(oifi, req))
+		goto bail;
+
+	oifi.ifi_slotnum = osb->max_slots;
+
+	for (i = 0; i < oifi.ifi_slotnum; i++) {
+		if (o2info_coherent(oifi)) {
+			inode_alloc = ocfs2_get_system_file_inode(osb, type, i);
+			if (!inode_alloc) {
+				mlog(ML_ERROR, "unable to get alloc inode in "
+				    "slot %u\n", i);
+				status = -EIO;
+				goto bail;
+			}
+		} else {
+			ocfs2_sprintf_system_inode_name(namebuf,
+							sizeof(namebuf),
+							type, i);
+			status = ocfs2_lookup_ino_from_name(osb->sys_root_inode,

fs/ocfs2/ioctl.c +21 -0

+		if (status < 0)
+			goto bail;
+	}
+
+	o2info_set_request_filled(oifi);
+
+	if (o2info_to_user(oifi, req))
+		goto bail;
+
+	status = 0;
+bail:
+	if (status)
+		o2info_set_request_error(oifi, req);
+
+	return status;
+}
+
 int ocfs2_info_handle_unknown(struct inode *inode,
 			      struct ocfs2_info_request __user *req)
 {

@@ -392,6 +510,10 @@ int ocfs2_info_handle_request(struct inode *inode,
 		if (oir.ir_size == sizeof(struct ocfs2_info_journal_size))
 			status = ocfs2_info_handle_journal_size(inode, req);
 		break;
+	case OCFS2_INFO_FREEINODE:
+		if (oir.ir_size == sizeof(struct ocfs2_info_freeinode))
+			status = ocfs2_info_handle_freeinode(inode, req);
+		break;
 	default:
 		status = ocfs2_info_handle_unknown(inode, req);
 		break;

fs/ocfs2/ocfs2_ioctl.h +0 -0

index b46f39b..6b4b39a 100644
@@ -142,6 +142,16 @@ struct ocfs2_info_journal_size {
 	__u64 ij_journal_size;
 };

Quoted 29 lines · Tristan Ye

The new code is dedicated to calculate free inodes number of all inode_allocs, then return the info to userpace in terms of an array.

Specially, flag 'OCFS2_INFO_FL_NON_COHERENT', manipulated by '--cluster-coherent' from userspace, is now going to be involved. setting the flag on means no cluster coherency considered, usually, userspace tools choose none-coherency strategy by default for the sake of performace.

Signed-off-by Tristan Ye <[email protected]>

---
 fs/ocfs2/ioctl.c       |  122 ++++++++++++++++++++++++++++++++++++++++++++++++
 fs/ocfs2/ocfs2_ioctl.h |   11 ++++
 2 files changed, 133 insertions(+), 0 deletions(-)

fs/ocfs2/ioctl.c +3 -0

index 731cf46..18812be 100644
@@ -23,6 +23,9 @@
 #include "ioctl.h"
 #include "resize.h"
 #include "refcounttree.h"
+#include "sysfile.h"
+#include "dir.h"
+#include "buffer_head_io.h"
 
 #include <linux/ext2_fs.h>
 

fs/ocfs2/ioctl.c static inline void __o2info_clear_request_filled(struct ocfs2_info_request *req) · line 73

Quoted 9 lines

fs/ocfs2/ioctl.c +6 -0

@@ -62,6 +65,13 @@ static inline void __o2info_clear_request_filled(struct ocfs2_info_request *req)
 #define o2info_clear_request_filled(a) \
 		__o2info_clear_request_filled((struct ocfs2_info_request *)&(a))
 
+static inline int __o2info_coherent(struct ocfs2_info_request *req)
+{
+	return (!(req->ir_flags & OCFS2_INFO_FL_NON_COHERENT));
+}
+
+#define o2info_coherent(a) __o2info_coherent((struct ocfs2_info_request *)&(a))

Same comment about typechecking as before.

Quoted 41 lines

fs/ocfs2/ioctl.c +34 -0

 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
 {
 	int status;

@@ -321,6 +331,114 @@ bail:
 	return status;
 }
 
+int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb,
+				struct inode *inode_alloc, u64 blkno,
+				struct ocfs2_info_freeinode *fi, u32 slot)
+{
+	int status = 0, unlock = 0;
+
+	struct buffer_head *bh = NULL;
+	struct ocfs2_dinode *dinode_alloc = NULL;
+
+	if (inode_alloc)
+		mutex_lock(&inode_alloc->i_mutex);
+
+	if (o2info_coherent(*fi)) {
+		status = ocfs2_inode_lock(inode_alloc, &bh, 0);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+		unlock = 1;
+	} else {
+		status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+	}
+
+	dinode_alloc = (struct ocfs2_dinode *)bh->b_data;
+
+	fi->ifi_stat[slot].lfi_total =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total);
+	fi->ifi_stat[slot].lfi_free =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) -
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_used);

fs/ocfs2/ioctl.c bail: · line 377

Quoted 10 lines

fs/ocfs2/ioctl.c +10 -0

+
+bail:
+	if (unlock)
+		ocfs2_inode_unlock(inode_alloc, 0);
+
+	if (inode_alloc)
+		mutex_unlock(&inode_alloc->i_mutex);
+
+	if (inode_alloc)
+		iput(inode_alloc);

    		^^^^^^^^^^^^^^^^^^

Is this iput necessary? I don't see a balancing ref in the function.

Quoted 38 lines

fs/ocfs2/ioctl.c +37 -0

+
+	brelse(bh);
+
+	mlog_exit(status);
+	return status;
+}
+
+int ocfs2_info_handle_freeinode(struct inode *inode,
+				struct ocfs2_info_request __user *req)
+{
+	u32 i;
+	u64 blkno = -1;
+	char namebuf[40];
+	int status = -EFAULT, type = INODE_ALLOC_SYSTEM_INODE;
+	struct ocfs2_info_freeinode oifi;
+	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+	struct inode *inode_alloc = NULL;
+
+	if (o2info_from_user(oifi, req))
+		goto bail;
+
+	oifi.ifi_slotnum = osb->max_slots;
+
+	for (i = 0; i < oifi.ifi_slotnum; i++) {
+		if (o2info_coherent(oifi)) {
+			inode_alloc = ocfs2_get_system_file_inode(osb, type, i);
+			if (!inode_alloc) {
+				mlog(ML_ERROR, "unable to get alloc inode in "
+				    "slot %u\n", i);
+				status = -EIO;
+				goto bail;
+			}
+		} else {
+			ocfs2_sprintf_system_inode_name(namebuf,
+							sizeof(namebuf),
+							type, i);
+			status = ocfs2_lookup_ino_from_name(osb->sys_root_inode,

fs/ocfs2/ioctl.c bail: · line 424

Quoted 10 lines

fs/ocfs2/ioctl.c +10 -0

+							    namebuf,
+							    strlen(namebuf),
+							    &blkno);
+			if (status < 0) {
+				status = -ENOENT;
+				goto bail;
+			}
+		}
+
+		status = ocfs2_info_scan_inode_alloc(osb, inode_alloc, blkno, &oifi, i);

You need the following here:

		iput(inode_alloc);
		inode_alloc = NULL;

Quoted 38 lines

fs/ocfs2/ioctl.c +21 -0

+		if (status < 0)
+			goto bail;
+	}
+
+	o2info_set_request_filled(oifi);
+
+	if (o2info_to_user(oifi, req))
+		goto bail;
+
+	status = 0;
+bail:
+	if (status)
+		o2info_set_request_error(oifi, req);
+
+	return status;
+}
+
 int ocfs2_info_handle_unknown(struct inode *inode,
 			      struct ocfs2_info_request __user *req)
 {

@@ -392,6 +510,10 @@ int ocfs2_info_handle_request(struct inode *inode,
 		if (oir.ir_size == sizeof(struct ocfs2_info_journal_size))
 			status = ocfs2_info_handle_journal_size(inode, req);
 		break;
+	case OCFS2_INFO_FREEINODE:
+		if (oir.ir_size == sizeof(struct ocfs2_info_freeinode))
+			status = ocfs2_info_handle_freeinode(inode, req);
+		break;
 	default:
 		status = ocfs2_info_handle_unknown(inode, req);
 		break;

fs/ocfs2/ocfs2_ioctl.h +0 -0

index b46f39b..6b4b39a 100644
@@ -142,6 +142,16 @@ struct ocfs2_info_journal_size {
 	__u64 ij_journal_size;
 };

fs/ocfs2/ocfs2_ioctl.h struct ocfs2_info_journal_size { · line 153

Quoted 10 lines

fs/ocfs2/ocfs2_ioctl.h +9 -0

 
+struct ocfs2_info_freeinode {
+	struct ocfs2_info_request ifi_req;
+	struct ocfs2_info_local_freeinode {
+		__u64 lfi_total;
+		__u64 lfi_free;
+	} ifi_stat[OCFS2_MAX_SLOTS];
+	__u32 ifi_slotnum; /* out */
+	__u32 ifi_pad;
+};

Any reason why we don't keep the array (ocfs2_info_local_freeinode) at the end of this structure like this:

struct ocfs2_info_freeinode {
	struct ocfs2_info_request ifi_req;
	__u32 ifi_slotnum; /* out */
	__u32 ifi_pad;
	struct ocfs2_info_local_freeinode {
		__u64 lfi_total;
		__u64 lfi_free;
	} ifi_stat[OCFS2_MAX_SLOTS];
};

	--Mark

--
Mark Fasheh

The new code is dedicated to calculate free inodes number of all inode_allocs, then return the info to userpace in terms of an array.

Specially, flag 'OCFS2_INFO_FL_NON_COHERENT', manipulated by '--cluster-coherent' from userspace, is now going to be involved. setting the flag on means no cluster coherency considered, usually, userspace tools choose none-coherency strategy by default for the sake of performace.

Signed-off-by Tristan Ye <[email protected]>

---
 fs/ocfs2/ioctl.c       |  122 ++++++++++++++++++++++++++++++++++++++++++++++++
 fs/ocfs2/ocfs2_ioctl.h |   11 ++++
 2 files changed, 133 insertions(+), 0 deletions(-)

fs/ocfs2/ioctl.c +59 -0

index 731cf46..18812be 100644
@@ -23,6 +23,9 @@
 #include "ioctl.h"
 #include "resize.h"
 #include "refcounttree.h"
+#include "sysfile.h"
+#include "dir.h"
+#include "buffer_head_io.h"
 
 #include <linux/ext2_fs.h>
 

@@ -62,6 +65,13 @@ static inline void __o2info_clear_request_filled(struct ocfs2_info_request *req)
 #define o2info_clear_request_filled(a) \
 		__o2info_clear_request_filled((struct ocfs2_info_request *)&(a))
 
+static inline int __o2info_coherent(struct ocfs2_info_request *req)
+{
+	return (!(req->ir_flags & OCFS2_INFO_FL_NON_COHERENT));
+}
+
+#define o2info_coherent(a) __o2info_coherent((struct ocfs2_info_request *)&(a))
+
 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
 {
 	int status;

@@ -321,6 +331,114 @@ bail:
 	return status;
 }
 
+int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb,
+				struct inode *inode_alloc, u64 blkno,
+				struct ocfs2_info_freeinode *fi, u32 slot)
+{
+	int status = 0, unlock = 0;
+
+	struct buffer_head *bh = NULL;
+	struct ocfs2_dinode *dinode_alloc = NULL;
+
+	if (inode_alloc)
+		mutex_lock(&inode_alloc->i_mutex);
+
+	if (o2info_coherent(*fi)) {
+		status = ocfs2_inode_lock(inode_alloc, &bh, 0);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+		unlock = 1;
+	} else {
+		status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+	}
+
+	dinode_alloc = (struct ocfs2_dinode *)bh->b_data;
+
+	fi->ifi_stat[slot].lfi_total =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total);
+	fi->ifi_stat[slot].lfi_free =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) -
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_used);
+
+bail:
+	if (unlock)
+		ocfs2_inode_unlock(inode_alloc, 0);
+
+	if (inode_alloc)
+		mutex_unlock(&inode_alloc->i_mutex);
+
+	if (inode_alloc)
+		iput(inode_alloc);
+
+	brelse(bh);
+
+	mlog_exit(status);
+	return status;

Quoted 95 lines · Tristan Ye

The new code is dedicated to calculate free inodes number of all inode_allocs, then return the info to userpace in terms of an array.

Specially, flag 'OCFS2_INFO_FL_NON_COHERENT', manipulated by '--cluster-coherent' from userspace, is now going to be involved. setting the flag on means no cluster coherency considered, usually, userspace tools choose none-coherency strategy by default for the sake of performace.

Signed-off-by Tristan Ye <[email protected]>

---
 fs/ocfs2/ioctl.c       |  122 ++++++++++++++++++++++++++++++++++++++++++++++++
 fs/ocfs2/ocfs2_ioctl.h |   11 ++++
 2 files changed, 133 insertions(+), 0 deletions(-)

fs/ocfs2/ioctl.c +59 -0

index 731cf46..18812be 100644
@@ -23,6 +23,9 @@
 #include "ioctl.h"
 #include "resize.h"
 #include "refcounttree.h"
+#include "sysfile.h"
+#include "dir.h"
+#include "buffer_head_io.h"
 
 #include <linux/ext2_fs.h>
 

@@ -62,6 +65,13 @@ static inline void __o2info_clear_request_filled(struct ocfs2_info_request *req)
 #define o2info_clear_request_filled(a) \
 		__o2info_clear_request_filled((struct ocfs2_info_request *)&(a))
 
+static inline int __o2info_coherent(struct ocfs2_info_request *req)
+{
+	return (!(req->ir_flags & OCFS2_INFO_FL_NON_COHERENT));
+}
+
+#define o2info_coherent(a) __o2info_coherent((struct ocfs2_info_request *)&(a))
+
 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
 {
 	int status;

@@ -321,6 +331,114 @@ bail:
 	return status;
 }
 
+int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb,
+				struct inode *inode_alloc, u64 blkno,
+				struct ocfs2_info_freeinode *fi, u32 slot)
+{
+	int status = 0, unlock = 0;
+
+	struct buffer_head *bh = NULL;
+	struct ocfs2_dinode *dinode_alloc = NULL;
+
+	if (inode_alloc)
+		mutex_lock(&inode_alloc->i_mutex);
+
+	if (o2info_coherent(*fi)) {
+		status = ocfs2_inode_lock(inode_alloc, &bh, 0);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+		unlock = 1;
+	} else {
+		status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
+		if (status < 0) {
+			mlog_errno(status);
+			goto bail;
+		}
+	}
+
+	dinode_alloc = (struct ocfs2_dinode *)bh->b_data;
+
+	fi->ifi_stat[slot].lfi_total =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total);
+	fi->ifi_stat[slot].lfi_free =
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) -
+		le32_to_cpu(dinode_alloc->id1.bitmap1.i_used);
+
+bail:
+	if (unlock)
+		ocfs2_inode_unlock(inode_alloc, 0);
+
+	if (inode_alloc)
+		mutex_unlock(&inode_alloc->i_mutex);
+
+	if (inode_alloc)
+		iput(inode_alloc);
+
+	brelse(bh);
+
+	mlog_exit(status);
+	return status;

fs/ocfs2/ioctl.c bail: · line 392

Quoted 10 lines

fs/ocfs2/ioctl.c +10 -0

+}
+
+int ocfs2_info_handle_freeinode(struct inode *inode,
+				struct ocfs2_info_request __user *req)
+{
+	u32 i;
+	u64 blkno = -1;
+	char namebuf[40];
+	int status = -EFAULT, type = INODE_ALLOC_SYSTEM_INODE;
+	struct ocfs2_info_freeinode oifi;

/build/jlbec/linux-2.6/working/fs/ocfs2/ioctl.c: In function ?ocfs2_info_handle_freeinode?:
/build/jlbec/linux-2.6/working/fs/ocfs2/ioctl.c:441: warning: the frame size of 4192 bytes is larger than 2048 bytes

This is speaking to the fact that you've put struct
ocfs2_info_freeinode oifi on the stack. It's over 4K in size. It needs to be allocated.

Please respin this and the FREEFRAG patch based on it.

Joel

Quoted 6 lines

/build/jlbec/linux-2.6/working/fs/ocfs2/ioctl.c: In function ?ocfs2_info_handle_freeinode?:
/build/jlbec/linux-2.6/working/fs/ocfs2/ioctl.c:441: warning: the frame size of 4192 bytes is larger than 2048 bytes

This is speaking to the fact that you've put struct
ocfs2_info_freeinode oifi on the stack. It's over 4K in size. It needs to be allocated.

Joel, great catch, how did you builder get warning like that, needs
to change makefile a bit?

And we're not allowed to put structure more than 2k, on stack for each function in kernel?

Joel, great catch, how did you builder get warning like that, needs
to change makefile a bit?

And we're not allowed to put structure more than 2k, on stack for each function in kernel?