1 /* $NetBSD: subr.c,v 1.19 2012/07/21 05:49:42 manu Exp $ */ 2 3 /*- 4 * Copyright (c) 2010-2011 Emmanuel Dreyfus. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 19 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <err.h> 31 #include <errno.h> 32 #include <sysexits.h> 33 #include <syslog.h> 34 #include <puffs.h> 35 #include <paths.h> 36 #include <sys/hash.h> 37 #include <sys/extattr.h> 38 39 #include "perfuse_priv.h" 40 41 struct perfuse_ns_map { 42 const char *pnm_ns; 43 const size_t pnm_nslen; 44 const int pnm_native_ns; 45 }; 46 47 #define PERFUSE_NS_MAP(ns, native_ns) \ 48 { ns ".", sizeof(ns), native_ns } 49 50 static __inline struct perfuse_node_hashlist *perfuse_nidhash(struct 51 perfuse_state *, uint64_t); 52 53 struct puffs_node * 54 perfuse_new_pn(struct puffs_usermount *pu, const char *name, 55 struct puffs_node *parent) 56 { 57 struct perfuse_state *ps = puffs_getspecific(pu); 58 struct puffs_node *pn; 59 struct perfuse_node_data *pnd; 60 61 if ((pnd = malloc(sizeof(*pnd))) == NULL) 62 DERR(EX_OSERR, "%s: malloc failed", __func__); 63 64 if ((pn = puffs_pn_new(pu, pnd)) == NULL) 65 DERR(EX_SOFTWARE, "%s: puffs_pn_new failed", __func__); 66 67 (void)memset(pnd, 0, sizeof(*pnd)); 68 pnd->pnd_rfh = FUSE_UNKNOWN_FH; 69 pnd->pnd_wfh = FUSE_UNKNOWN_FH; 70 pnd->pnd_nodeid = PERFUSE_UNKNOWN_NODEID; 71 if (parent != NULL) { 72 pnd->pnd_parent_nodeid = PERFUSE_NODE_DATA(parent)->pnd_nodeid; 73 } else { 74 pnd->pnd_parent_nodeid = FUSE_ROOT_ID; 75 } 76 pnd->pnd_fuse_nlookup = 0; 77 pnd->pnd_puffs_nlookup = 0; 78 pnd->pnd_pn = (puffs_cookie_t)pn; 79 if (strcmp(name, "..") != 0) 80 (void)strlcpy(pnd->pnd_name, name, MAXPATHLEN); 81 else 82 pnd->pnd_name[0] = 0; /* anonymous for now */ 83 TAILQ_INIT(&pnd->pnd_pcq); 84 85 puffs_pn_setpriv(pn, pnd); 86 87 ps->ps_nodecount++; 88 89 return pn; 90 } 91 92 void 93 perfuse_destroy_pn(struct puffs_usermount *pu, struct puffs_node *pn) 94 { 95 struct perfuse_state *ps = puffs_getspecific(pu); 96 struct perfuse_node_data *pnd; 97 98 if ((pnd = puffs_pn_getpriv(pn)) != NULL) { 99 if (pnd->pnd_all_fd != NULL) 100 free(pnd->pnd_all_fd); 101 102 if (pnd->pnd_dirent != NULL) 103 free(pnd->pnd_dirent); 104 105 #ifdef PERFUSE_DEBUG 106 if (pnd->pnd_flags & PND_OPEN) 107 DERRX(EX_SOFTWARE, "%s: file open", __func__); 108 109 if (!TAILQ_EMPTY(&pnd->pnd_pcq)) 110 DERRX(EX_SOFTWARE, "%s: non empty pnd_pcq", __func__); 111 112 pnd->pnd_flags |= PND_INVALID; 113 #endif /* PERFUSE_DEBUG */ 114 115 free(pnd); 116 } 117 118 puffs_pn_put(pn); 119 120 ps->ps_nodecount--; 121 122 return; 123 } 124 125 void 126 perfuse_new_fh(puffs_cookie_t opc, uint64_t fh, int mode) 127 { 128 struct perfuse_node_data *pnd; 129 130 pnd = PERFUSE_NODE_DATA(opc); 131 132 if (mode & FWRITE) { 133 if (pnd->pnd_flags & PND_WFH) 134 DERRX(EX_SOFTWARE, "%s: opc = %p, write fh already set", 135 __func__, (void *)opc); 136 pnd->pnd_wfh = fh; 137 pnd->pnd_flags |= PND_WFH; 138 } 139 140 if (mode & FREAD) { 141 if (pnd->pnd_flags & PND_RFH) 142 DERRX(EX_SOFTWARE, "%s: opc = %p, read fh already set", 143 __func__, (void *)opc); 144 pnd->pnd_rfh = fh; 145 pnd->pnd_flags |= PND_RFH; 146 } 147 148 return; 149 } 150 151 void 152 perfuse_destroy_fh(puffs_cookie_t opc, uint64_t fh) 153 { 154 struct perfuse_node_data *pnd; 155 156 pnd = PERFUSE_NODE_DATA(opc); 157 158 if (fh == pnd->pnd_rfh) { 159 if (!(pnd->pnd_flags & PND_RFH) && (fh != FUSE_UNKNOWN_FH)) 160 DERRX(EX_SOFTWARE, 161 "%s: opc = %p, unset rfh = %"PRIx64"", 162 __func__, (void *)opc, fh); 163 pnd->pnd_rfh = FUSE_UNKNOWN_FH; 164 pnd->pnd_flags &= ~PND_RFH; 165 } 166 167 if (fh == pnd->pnd_wfh) { 168 if (!(pnd->pnd_flags & PND_WFH) && (fh != FUSE_UNKNOWN_FH)) 169 DERRX(EX_SOFTWARE, 170 "%s: opc = %p, unset wfh = %"PRIx64"", 171 __func__, (void *)opc, fh); 172 pnd->pnd_wfh = FUSE_UNKNOWN_FH; 173 pnd->pnd_flags &= ~PND_WFH; 174 } 175 176 return; 177 } 178 179 uint64_t 180 perfuse_get_fh(puffs_cookie_t opc, int mode) 181 { 182 struct perfuse_node_data *pnd; 183 184 pnd = PERFUSE_NODE_DATA(opc); 185 186 if (mode & FWRITE) { 187 if (pnd->pnd_flags & PND_WFH) 188 return pnd->pnd_wfh; 189 } 190 191 if (mode & FREAD) { 192 if (pnd->pnd_flags & PND_RFH) 193 return pnd->pnd_rfh; 194 195 if (pnd->pnd_flags & PND_WFH) 196 return pnd->pnd_wfh; 197 198 } 199 200 return FUSE_UNKNOWN_FH; 201 } 202 203 /* ARGSUSED0 */ 204 char * 205 perfuse_node_path(struct perfuse_state *ps, puffs_cookie_t opc) 206 { 207 static char buf[MAXPATHLEN + 1]; 208 209 #if 0 210 if (node_path(ps, opc, buf, sizeof(buf)) == 0) 211 sprintf(buf, "/"); 212 #endif 213 sprintf(buf, "%s", PERFUSE_NODE_DATA(opc)->pnd_name); 214 215 return buf; 216 } 217 218 const char * 219 perfuse_native_ns(const int attrnamespace, const char *attrname, 220 char *fuse_attrname) 221 { 222 const struct perfuse_ns_map *pnm; 223 const struct perfuse_ns_map perfuse_ns_map[] = { 224 PERFUSE_NS_MAP("trusted", EXTATTR_NAMESPACE_SYSTEM), 225 PERFUSE_NS_MAP("security", EXTATTR_NAMESPACE_SYSTEM), 226 PERFUSE_NS_MAP("system", EXTATTR_NAMESPACE_SYSTEM), 227 PERFUSE_NS_MAP("user", EXTATTR_NAMESPACE_USER), 228 { NULL, 0, EXTATTR_NAMESPACE_USER }, 229 }; 230 231 /* 232 * If attribute has a reserved Linux namespace (e.g.: trusted.foo) 233 * and that namespace matches the requested native namespace 234 * we have nothing to do. 235 * Otherwise we have either: 236 * (system|trusted|security).* with user namespace: prepend user. 237 * anything else with system napespace: prepend system. 238 */ 239 for (pnm = perfuse_ns_map; pnm->pnm_ns; pnm++) { 240 if (strncmp(attrname, pnm->pnm_ns, pnm->pnm_nslen) != 0) 241 continue; 242 243 if (attrnamespace == pnm->pnm_native_ns) 244 return attrname; 245 246 /* (system|trusted|security).* with user namespace */ 247 if (attrnamespace == EXTATTR_NAMESPACE_USER) { 248 (void)snprintf(fuse_attrname, LINUX_XATTR_NAME_MAX, 249 "user.%s", attrname); 250 return (const char *)fuse_attrname; 251 } 252 } 253 254 /* anything else with system napespace */ 255 if (attrnamespace == EXTATTR_NAMESPACE_SYSTEM) { 256 (void)snprintf(fuse_attrname, LINUX_XATTR_NAME_MAX, 257 "system.%s", attrname); 258 return (const char *)fuse_attrname; 259 } 260 261 return (const char *)attrname; 262 } 263 264 static __inline struct perfuse_node_hashlist * 265 perfuse_nidhash(struct perfuse_state *ps, uint64_t nodeid) 266 { 267 uint32_t hash; 268 269 hash = hash32_buf(&nodeid, sizeof(nodeid), HASH32_BUF_INIT); 270 271 return &ps->ps_nidhash[hash % ps->ps_nnidhash]; 272 } 273 274 struct perfuse_node_data * 275 perfuse_node_bynodeid(struct perfuse_state *ps, uint64_t nodeid) 276 { 277 struct perfuse_node_hashlist *plist; 278 struct perfuse_node_data *pnd; 279 280 plist = perfuse_nidhash(ps, nodeid); 281 282 LIST_FOREACH(pnd, plist, pnd_nident) 283 if (pnd->pnd_nodeid == nodeid) 284 break; 285 286 return pnd; 287 } 288 289 void 290 perfuse_node_cache(struct perfuse_state *ps, puffs_cookie_t opc) 291 { 292 struct perfuse_node_data *pnd = PERFUSE_NODE_DATA(opc); 293 struct perfuse_node_hashlist *nidlist; 294 295 if (pnd->pnd_flags & PND_REMOVED) 296 DERRX(EX_SOFTWARE, "%s: \"%s\" already removed", 297 __func__, pnd->pnd_name); 298 299 nidlist = perfuse_nidhash(ps, pnd->pnd_nodeid); 300 LIST_INSERT_HEAD(nidlist, pnd, pnd_nident); 301 302 return; 303 } 304 305 void 306 perfuse_cache_flush(puffs_cookie_t opc) 307 { 308 struct perfuse_node_data *pnd = PERFUSE_NODE_DATA(opc); 309 310 if (pnd->pnd_flags & PND_REMOVED) 311 DERRX(EX_SOFTWARE, "%s: \"%s\" already removed", 312 __func__, pnd->pnd_name); 313 314 LIST_REMOVE(pnd, pnd_nident); 315 316 return; 317 } 318