From ca9f518eadeb7edd8e438a6542d3caec9bc3bb74 Mon Sep 17 00:00:00 2001 From: Mike Marshall Date: Fri, 26 Feb 2016 10:21:12 -0500 Subject: [PATCH] Orangefs: code sanitation. Signed-off-by: Mike Marshall --- fs/orangefs/devorangefs-req.c | 20 ++++++++-------- fs/orangefs/orangefs-mod.c | 11 +++++---- fs/orangefs/waitqueue.c | 44 ++++++++++++++++++++++++----------- 3 files changed, 46 insertions(+), 29 deletions(-) diff --git a/fs/orangefs/devorangefs-req.c b/fs/orangefs/devorangefs-req.c index 0db3a57f974d..e3934c06b96a 100644 --- a/fs/orangefs/devorangefs-req.c +++ b/fs/orangefs/devorangefs-req.c @@ -46,6 +46,10 @@ static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op) list_add_tail(&op->list, &htable_ops_in_progress[index]); } +/* + * find the op with this tag and remove it from the in progress + * hash table. + */ static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag) { struct orangefs_kernel_op_s *op, *next; @@ -190,8 +194,10 @@ restart: return -EAGAIN; } - gossip_debug(GOSSIP_DEV_DEBUG, "orangefs: reading op tag %llu %s\n", - llu(cur_op->tag), get_opname_string(cur_op)); + gossip_debug(GOSSIP_DEV_DEBUG, "%s: reading op tag %llu %s\n", + __func__, + llu(cur_op->tag), + get_opname_string(cur_op)); /* * Such an op should never be on the list in the first place. If so, we @@ -204,6 +210,7 @@ restart: spin_unlock(&orangefs_request_list_lock); return -EAGAIN; } + list_del_init(&cur_op->list); spin_unlock(&orangefs_request_list_lock); @@ -323,6 +330,7 @@ static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb, return -EPROTO; } + /* remove the op from the in progress hash table */ op = orangefs_devreq_remove_op(head.tag); if (!op) { gossip_err("WARNING: No one's waiting for tag %llu\n", @@ -486,15 +494,7 @@ static int orangefs_devreq_release(struct inode *inode, struct file *file) gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n", (unmounted ? "UNMOUNTED" : "MOUNTED")); - /* - * Walk through the list of ops in the request list, mark them - * as purged and wake them up. - */ purge_waiting_ops(); - /* - * Walk through the hash table of in progress operations; mark - * them as purged and wake them up - */ purge_inprogress_ops(); orangefs_bufmap_run_down(); diff --git a/fs/orangefs/orangefs-mod.c b/fs/orangefs/orangefs-mod.c index 965959cb11d1..a4e08dd3e669 100644 --- a/fs/orangefs/orangefs-mod.c +++ b/fs/orangefs/orangefs-mod.c @@ -119,10 +119,10 @@ static int __init orangefs_init(void) if (gossip_debug_mask != 0) kernel_mask_set_mod_init = true; - /* print information message to the system log */ - pr_info("orangefs: orangefs_init called with debug mask: :%s: :%llx:\n", - kernel_debug_string, - (unsigned long long)gossip_debug_mask); + pr_info("%s: called with debug mask: :%s: :%llx:\n", + __func__, + kernel_debug_string, + (unsigned long long)gossip_debug_mask); ret = bdi_init(&orangefs_backing_dev_info); @@ -147,7 +147,8 @@ static int __init orangefs_init(void) /* Initialize the orangefsdev subsystem. */ ret = orangefs_dev_init(); if (ret < 0) { - gossip_err("orangefs: could not initialize device subsystem %d!\n", + gossip_err("%s: could not initialize device subsystem %d!\n", + __func__, ret); goto cleanup_inode; } diff --git a/fs/orangefs/waitqueue.c b/fs/orangefs/waitqueue.c index 1eadf69cc919..edfd921cf6ec 100644 --- a/fs/orangefs/waitqueue.c +++ b/fs/orangefs/waitqueue.c @@ -75,7 +75,7 @@ retry_servicing: /* * If ORANGEFS_OP_NO_MUTEX was set in flags, we need to avoid - * aquiring the request_mutex because we're servicing a + * acquiring the request_mutex because we're servicing a * high priority remount operation and the request_mutex is * already taken. */ @@ -91,7 +91,8 @@ retry_servicing: if (ret < 0) { op->downcall.status = ret; gossip_debug(GOSSIP_WAIT_DEBUG, - "orangefs: service_operation interrupted.\n"); + "%s: service_operation interrupted.\n", + __func__); return ret; } } @@ -127,9 +128,9 @@ retry_servicing: ret, op); + /* got matching downcall; make sure status is in errno format */ if (!ret) { spin_unlock(&op->lock); - /* got matching downcall; make sure status is in errno format */ op->downcall.status = orangefs_normalize_to_errno(op->downcall.status); ret = op->downcall.status; @@ -144,8 +145,8 @@ retry_servicing: } /* - * remove waiting ops from the request list or - * remove in-progress ops from the in-progress list. + * remove a waiting op from the request list or + * remove an in-progress op from the in-progress list. */ orangefs_clean_up_interrupted_operation(op); @@ -179,6 +180,7 @@ out: return ret; } +/* This can get called on an I/O op if it had a bad service_operation. */ bool orangefs_cancel_op_in_progress(struct orangefs_kernel_op_s *op) { u64 tag = op->tag; @@ -206,23 +208,31 @@ bool orangefs_cancel_op_in_progress(struct orangefs_kernel_op_s *op) spin_unlock(&op->lock); spin_unlock(&orangefs_request_list_lock); - gossip_debug(GOSSIP_UTILS_DEBUG, + gossip_debug(GOSSIP_WAIT_DEBUG, "Attempting ORANGEFS operation cancellation of tag %llu\n", llu(tag)); return true; } -static void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s *op) +/* + * Change an op to the "given up" state and remove it from its list. + */ +static void + orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s *op) { /* * handle interrupted cases depending on what state we were in when - * the interruption is detected. there is a coarse grained lock - * across the operation. + * the interruption is detected. * * Called with op->lock held. */ + + /* + * List manipulation code elsewhere will ignore ops that + * have been given up upon. + */ op->op_state |= OP_VFS_STATE_GIVEN_UP; - /* from that point on it can't be moved by anybody else */ + if (list_empty(&op->list)) { /* caught copying to/from daemon */ BUG_ON(op_state_serviced(op)); @@ -259,12 +269,12 @@ static void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s } /* - * sleeps on waitqueue waiting for matching downcall. - * if client-core finishes servicing, then we are good to go. + * Sleeps on waitqueue waiting for matching downcall. + * If client-core finishes servicing, then we are good to go. * else if client-core exits, we get woken up here, and retry with a timeout * - * Post when this call returns to the caller, the specified op will no - * longer be on any list or htable. + * When this call returns to the caller, the specified op will no + * longer be in either the in_progress hash table or on the request list. * * Returns 0 on success and -errno on failure * Errors are: @@ -281,6 +291,12 @@ static int wait_for_matching_downcall(struct orangefs_kernel_op_s *op, { long n; + /* + * There's a "schedule_timeout" inside of these wait + * primitives, during which the op is out of the hands of the + * user process that needs something done and is being + * manipulated by the client-core process. + */ if (interruptible) n = wait_for_completion_interruptible_timeout(&op->waitq, timeout); -- 2.39.5