symlink.c revision 67a235f5e5893bc7dc86cf0e867fdb3f9041df18
1/* 2 * GPL HEADER START 3 * 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 only, 8 * as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License version 2 for more details (a copy is included 14 * in the LICENSE file that accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License 17 * version 2 along with this program; If not, see 18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf 19 * 20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 21 * CA 95054 USA or visit www.sun.com if you need additional information or 22 * have any questions. 23 * 24 * GPL HEADER END 25 */ 26/* 27 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. 28 * Use is subject to license terms. 29 * 30 * Copyright (c) 2011, 2012, Intel Corporation. 31 */ 32/* 33 * This file is part of Lustre, http://www.lustre.org/ 34 * Lustre is a trademark of Sun Microsystems, Inc. 35 */ 36 37#include <linux/fs.h> 38#include <linux/mm.h> 39#include <linux/stat.h> 40#define DEBUG_SUBSYSTEM S_LLITE 41 42#include "../include/lustre_lite.h" 43#include "llite_internal.h" 44 45static int ll_readlink_internal(struct inode *inode, 46 struct ptlrpc_request **request, char **symname) 47{ 48 struct ll_inode_info *lli = ll_i2info(inode); 49 struct ll_sb_info *sbi = ll_i2sbi(inode); 50 int rc, symlen = i_size_read(inode) + 1; 51 struct mdt_body *body; 52 struct md_op_data *op_data; 53 54 *request = NULL; 55 56 if (lli->lli_symlink_name) { 57 int print_limit = min_t(int, PAGE_SIZE - 128, symlen); 58 59 *symname = lli->lli_symlink_name; 60 /* If the total CDEBUG() size is larger than a page, it 61 * will print a warning to the console, avoid this by 62 * printing just the last part of the symlink. */ 63 CDEBUG(D_INODE, "using cached symlink %s%.*s, len = %d\n", 64 print_limit < symlen ? "..." : "", print_limit, 65 (*symname) + symlen - print_limit, symlen); 66 return 0; 67 } 68 69 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, symlen, 70 LUSTRE_OPC_ANY, NULL); 71 if (IS_ERR(op_data)) 72 return PTR_ERR(op_data); 73 74 op_data->op_valid = OBD_MD_LINKNAME; 75 rc = md_getattr(sbi->ll_md_exp, op_data, request); 76 ll_finish_md_op_data(op_data); 77 if (rc) { 78 if (rc != -ENOENT) 79 CERROR("inode %lu: rc = %d\n", inode->i_ino, rc); 80 GOTO (failed, rc); 81 } 82 83 body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY); 84 LASSERT(body != NULL); 85 if ((body->valid & OBD_MD_LINKNAME) == 0) { 86 CERROR("OBD_MD_LINKNAME not set on reply\n"); 87 GOTO(failed, rc = -EPROTO); 88 } 89 90 LASSERT(symlen != 0); 91 if (body->eadatasize != symlen) { 92 CERROR("inode %lu: symlink length %d not expected %d\n", 93 inode->i_ino, body->eadatasize - 1, symlen - 1); 94 GOTO(failed, rc = -EPROTO); 95 } 96 97 *symname = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_MD); 98 if (*symname == NULL || 99 strnlen(*symname, symlen) != symlen - 1) { 100 /* not full/NULL terminated */ 101 CERROR("inode %lu: symlink not NULL terminated string" 102 "of length %d\n", inode->i_ino, symlen - 1); 103 GOTO(failed, rc = -EPROTO); 104 } 105 106 OBD_ALLOC(lli->lli_symlink_name, symlen); 107 /* do not return an error if we cannot cache the symlink locally */ 108 if (lli->lli_symlink_name) { 109 memcpy(lli->lli_symlink_name, *symname, symlen); 110 *symname = lli->lli_symlink_name; 111 } 112 return 0; 113 114failed: 115 return rc; 116} 117 118static void *ll_follow_link(struct dentry *dentry, struct nameidata *nd) 119{ 120 struct inode *inode = dentry->d_inode; 121 struct ptlrpc_request *request = NULL; 122 int rc; 123 char *symname = NULL; 124 125 CDEBUG(D_VFSTRACE, "VFS Op\n"); 126 /* Limit the recursive symlink depth to 5 instead of default 127 * 8 links when kernel has 4k stack to prevent stack overflow. 128 * For 8k stacks we need to limit it to 7 for local servers. */ 129 if (THREAD_SIZE < 8192 && current->link_count >= 6) { 130 rc = -ELOOP; 131 } else if (THREAD_SIZE == 8192 && current->link_count >= 8) { 132 rc = -ELOOP; 133 } else { 134 ll_inode_size_lock(inode); 135 rc = ll_readlink_internal(inode, &request, &symname); 136 ll_inode_size_unlock(inode); 137 } 138 if (rc) { 139 ptlrpc_req_finished(request); 140 request = NULL; 141 symname = ERR_PTR(rc); 142 } 143 144 nd_set_link(nd, symname); 145 /* symname may contain a pointer to the request message buffer, 146 * we delay request releasing until ll_put_link then. 147 */ 148 return request; 149} 150 151static void ll_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) 152{ 153 ptlrpc_req_finished(cookie); 154} 155 156struct inode_operations ll_fast_symlink_inode_operations = { 157 .readlink = generic_readlink, 158 .setattr = ll_setattr, 159 .follow_link = ll_follow_link, 160 .put_link = ll_put_link, 161 .getattr = ll_getattr, 162 .permission = ll_inode_permission, 163 .setxattr = ll_setxattr, 164 .getxattr = ll_getxattr, 165 .listxattr = ll_listxattr, 166 .removexattr = ll_removexattr, 167}; 168