/* * NAME: jfs_mknod(dvp, name, mode, dev, crp) * * FUNCTION: make a new object in directory <dvp> with mode = <mode>, * name = <pname>, and rdev = <dev>. * * PARAMETER: dvp - directory vnode * name - name of new object * mode - create mode (rwxrwxrwx). * dev - new device number if block/character-special file * crp - credential * * RETURN: Errors from subroutines * * note: JFS allows mknod() to create a special file. * XPG4.2: the only portable use of mknod() is to create a FIFO-special file * with mode = S_IFIFO and dev = 0. */ jfs_mknod( struct vnode *dvp, caddr_t name, mode_t mode, dev_t dev, struct ucred *crp) { int32 rc; int32 tid; inode_t *dip = VP2IP(dvp); inode_t *ip; ino_t ino; component_t dname; struct vfs *vfsp = dvp->v_vfsp; btstack_t btstack; inode_t *iplist[2]; /* JFS does NOT support mknod() of directory */ if ((mode & IFMT) == IFDIR) return EISDIR; if ((mode & IFMT) != IFIFO && (mode & IFMT) != IFSOCK) if (rc = privcheck_cr(DEV_CONFIG, crp)) return rc; IWRITE_LOCK(dip); txBegin(dip->i_ipmnt, &tid, 0); /* validate search+write permission on parent directory */ if (rc = iAccess(dip, IEXEC|IWRITE, crp)) goto out1; /* * scan parent directory for entry/freespace * (dtSearch() returns parent directory page pinned) */ dname.name = name; dname.namlen = strlen(name); if (rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE)) goto out1; /* * allocate in-memory+on-disk inode: * (iAlloc() returns new, locked inode) */ if (rc = iAlloc(vfsp, dip, mode, &ip, crp)) { /* release parent directory page */ BT_PUTSEARCH(&btstack); goto out1; } /* * create entry in parent directory * (dtInsert() releases parent directory page) */ ino = ip->i_number; if (rc = dtInsert(tid, dip, &dname, &ino, &btstack)) { /* discard the new inode */ ip->i_nlink = 0; goto out2; } /* * fo a block or character special file, the passed-in device number * needs to be set into the inode's device field and the gnode's * "real device" field. */ if ((ip->i_mode & IFMT) == IFBLK || (ip->i_mode & IFMT) == IFCHR) { ip->i_rdev = dev; IP2GP(ip)->gn_rdev = dev; } imark(ip, IACC|ICHG|IUPD|IFSYNC); /* update parent directory inode */ imark(dip, ICHG|IUPD|IFSYNC); /* * insert entry for the new file to dnlc */ ncEnter(dip->i_ipimap, dip->i_number, &dname, ino, NULL); iplist[0] = dip; iplist[1] = ip; rc = txCommit(tid, 2, &iplist[0], 0); out2: IWRITE_UNLOCK(ip); ICACHE_LOCK(); iput(ip, vfsp); ICACHE_UNLOCK(); out1: IWRITE_UNLOCK(dip); txEnd(tid); return rc; }
/* * NAME: pathlookup_pc * * FUNCTION: Lookup path, preserving case. * Lookup path, copying each component into output string * preserving its case. * * PARAMETERS: vfsp - pointer to VFS * path - full path name * path_pc - output - full path name w/preserved case * * RETURN: errors from subroutines. * * NOTES: We assume path is in canonical form: "X:\<path>" where there * are no extraneous backslashes and . and .. have been removed. * * dtFind is not very efficient for finding a directory entry * without wildcards, but infolevel 7 does not seem to actually * be used anywhere, so it must not be too important. */ int32 pathlookup_pc( struct vfs *vfsp, UniChar *path, /* input - Path */ UniChar *path_pc) /* output - path w/preserved case */ { int32 comp_len; uint32 count; UniChar *component; struct dirent *dbuf; inode_t *ip; int32 offset; UniChar *outptr = path_pc; component_t pattern; int rc; UniChar *slash; int32 tbytes; struct vnode *vp; if (vfsp == NULL) { jERROR(2,("pathlookup_pc: invalid VPB!\n")); return ENOTDIR; } /* Copy "X:\" to output string */ UniStrncpy(outptr, path, 3); outptr += 3; path += 3; if (*path == 0) { /* Trivial case "X:\" */ *outptr = 0; return NO_ERROR; } component = (UniChar *)allocpool(unipool, 0); if (component == 0) return ENOSPC; pattern.name = component; dbuf = (struct dirent *)allocpool(dirent_pool, 0); if (dbuf == 0) { freepool(unipool, (caddr_t *)component); return ENOSPC; } vp = vfsp->vfs_mntd; /* vnode of root directory */ jfs_hold(vp); while (path) { slash = UniStrchr(path, '\\'); if (slash) { comp_len = slash - path; slash++; } else comp_len = UniStrlen(path); UniStrncpy(component, path, comp_len); component[comp_len] = 0; UniStrupr(component); /* Convert to upper case */ pattern.namlen = comp_len; path = slash; offset = 0; count = 1; tbytes = 0; rc = dtFind(VP2IP(vp), &pattern, 0, &offset, &count, PSIZE, &tbytes, dbuf); jfs_rele(vp); if (rc || (count == 0)) { freepool(dirent_pool, (caddr_t *)dbuf); freepool(unipool, (caddr_t *)component); return ENOENT; } UniStrncpy(outptr, dbuf->d_name, dbuf->d_namlen); outptr += dbuf->d_namlen; if (path) { ICACHE_LOCK(); rc = iget(vfsp, dbuf->d_ino, &ip, 0); ICACHE_UNLOCK(); if (rc) { freepool(dirent_pool, (caddr_t *)dbuf); freepool(unipool, (caddr_t *)component); return rc; } vp = IP2VP(ip); *(outptr++) = '\\'; } else *outptr = 0; } freepool(dirent_pool, (caddr_t *)dbuf); freepool(unipool, (caddr_t *)component); return NO_ERROR; }
/* * NAME: jfs_lookup(dvp, vpp, pname, flag, vattrp, crp) * * FUNCTION: resolve <pname> in directory <dvp> to vnode <vpp> * with a reference acquired and attribute <vattrp>. * * PARAMETERS: dvp _ directory vnode * vpp - object vnode (out) * pname - object name * flag - * vattrp - object attribute (out) * crp - credential * * RETURN: errors from subroutines. */ jfs_lookup( struct vnode *dvp, struct vnode **vpp, UniChar *pname, /* NULL terminated */ int32 flag, struct vattr *vattrp, struct ucred *crp) { int32 rc = 0; struct vfs *vfsp = dvp->v_vfsp; inode_t *dip = VP2IP(dvp); /* parent directory inode */ ino_t ino; /* object i_number */ inode_t *ip; /* object inode */ component_t dname; /* object name */ ncookie_t ncookie; btstack_t btstack; NOISE(1,("jfs_lookup: dip:0x%08x name:%s\n", dip, pname)); *vpp = NULL; /* <dvp> must be a directory */ if ((dip->i_mode & IFMT) != IFDIR) return ENOTDIR; IREAD_LOCK(dip); if (dip->i_nlink == 0) { rc = ENOENT; goto out; } /* * resolve name to i_number via dnlc/directory lookup */ getInumber: /* * for "." or "..", lookup directory inode */ if (pname[0] == '.') { /* looking up ".." */ if (pname[1] == '.' && pname[2] == '\0') { ino = dip->i_parent; goto getInode; } /* looking up "." */ else if (pname[1] == '\0') { ip = dip; jfs_hold(dvp); *vpp = dvp; goto getAttribute; } } /* * search dnlc/directory */ dname.name = pname; dname.namlen = UniStrlen(pname); if ((ino = ncLookup(dip->i_ipimap, dip->i_number, &dname, &ncookie)) == 0) { /* * dnlc miss: search directory */ if (rc = dtSearch(dip, &dname, &ino, &btstack, JFS_LOOKUP)) goto out; /* insert name entry to dnlc */ ncEnter(dip->i_ipimap, dip->i_number, &dname, ino, &ncookie); } /* * resolve i_number to inode/vnode with a reference */ getInode: ICACHE_LOCK(); rc = iget(vfsp, ino, &ip, 0); ICACHE_UNLOCK(); if (rc) goto out; *vpp = IP2VP(ip); /* * get attribute */ getAttribute: if (vattrp != NULL) get_vattr(ip, vattrp); out: IREAD_UNLOCK(dip); NOISE(1,("jfs_lookup: rc:%d\n", rc)); return rc; }
/* * NAME: jfs_checkpath * * FUNCTION: Search the directory tree rooted with topar_ip to see if * it includes from_ip * * PARAMETERS: * from_ip - pointer to original directory inode * frompar_ip - pointer to parent of from_ip * topar_ip - pointer to destination parent inode * vfst - * * NOTES: RENAME_LOCK() of mount inode is used to serialize renaming * within an aggregate. This prevents someone from modifying * behind us as we walk up the tree. Since we hold the rename * lock, we don't need to lock each parent along the directory * tree. We already have a lock on a directory child, so none of * the directories we visit will be empty. Therefore, they cannot * be removed until our rename is complete. This will work as long * as we continue to not support unlink() of a directory. * * RETURN: 0 - from_ip is not a parent of topar_ip. * != 0 - from_ip is a parent or some other error. */ static int32 jfs_checkpath( inode_t *from_ip, inode_t *frompar_ip, inode_t *topar_ip, struct vfs *vfst) { ino_t par_ino; inode_t *parent_ip; int32 rc = 0; if (topar_ip->i_number == ROOT_I) { /* * We have reached the root and not found the source so we know * we don't have an orphan */ return 0; } /* * Walk up the destination directory tree looking for orphans */ par_ino = ((dtroot_t *)&(topar_ip->i_btroot))->header.idotdot; while(1) { if (par_ino <= 0) { /* We have hit a bad dotdot entry */ assert(0); } if (par_ino == ROOT_I || par_ino == frompar_ip->i_number) { rc = 0; break; } if (par_ino == from_ip->i_number) { /* * Uh-oh: we have an orphan situation */ rc = EINVAL; break; } ICACHE_LOCK(); rc = iget(vfst, par_ino, &parent_ip, 0); ICACHE_UNLOCK(); if (rc != 0) { break; } par_ino = ((dtroot_t *)&(parent_ip->i_btroot))->header.idotdot; ICACHE_LOCK(); iput(parent_ip, vfst); ICACHE_UNLOCK(); } return rc; }
/* * NAME: jfs_rename * * FUNCTION: rename a file or directory * * PARAMETER: from_vp - pointer to source vnode * frompar_vp - pointer to source parent vnode * from_name - original name * to_vp - pointer to target vnode (if it exists) * topar_vp - pointer to target parent vnode * to_name - new name * crp - pointer to caller's credentials * * RETURN: errors from subroutines * * JFS supports sticky bit permission. * * normally, to rename an object, user needs execute and write * permission of the directory containing the object as well as * on the target directory. * EACCESS: if S_ISVTX (aka sticky) bit is set for a directory, * a file in the directory can be renamed only if * the user has write permission for the directory, and * either owns the file, owns the directory, or * is the superuser (or have appropriate privileges). * (e.g., /tmp in which any user can create a file but * should not be able to delete or rename files owned * by others) [XPG4.2] * * Basic algorithm is: * * 1) Check validity of parameters and then obtain locks on the source parent * directory, destination parent directory, source, and the destination * inode. This ensures neither the source or destination will be deleted out * from underneath us. It also ensures the source or destination won't be * modified before we finish. * 2) Link source to destination. If destination already exists, * delete it first. * 3) Unlink source reference to inode if still around. If a * directory was moved and the parent of the destination * is different from the source, patch the ".." entry in the * directory. * * The transaction log needs to have the changes journalled in such a * way that a crash meets the requirement that the destination always * exists (if it existed before). For directory objects it is critical * that the changes in i-numbers occur in such a way that loops and * orphans aren't created by a crash. */ int32 jfs_rename( struct vnode *from_vp, /* source vnode */ struct vnode *frompar_vp, /* source parent vnode */ UniChar *from_name, /* source name */ struct vnode *to_vp, /* destination vnode */ struct vnode *topar_vp, /* destination parent vnode */ UniChar *to_name, /* destination name */ struct dasd_usage *from_dlim, /* dasd usage structure for source F226941 */ struct dasd_usage *to_dlim, /* dasd usage structure for dest F226941 */ uint32 flags) /* INEWNAME if new pathname not 8.3 */ { inode_t *ipmnt; int32 tid = -1; /* Transaction ID */ int32 txCount = 0; /* Count of inodes in txList */ inode_t *txList[4]; /* List of modified inodes */ inode_t *from_ip = VP2IP (from_vp); /* Source inode */ inode_t *frompar_ip = VP2IP (frompar_vp); /* Source parent inode */ inode_t *to_ip = to_vp ? VP2IP (to_vp) : 0; /* Target inode (if it exists) */ inode_t *topar_ip = VP2IP (topar_vp); /* Target parent inode */ struct vfs *vfsf = frompar_vp->v_vfsp; struct vfs *vfst = topar_vp->v_vfsp; int32 doingdirectory = 0, /* Source inode is a directory */ newparent = 0; /* New i-number of parent */ int32 got_from = 0, got_to = 0; btstack_t btstack; /* Temporary stack for B-tree struct */ component_t dname; /* Directory name structure */ ino_t ino; /* I-number for directory searches */ int32 error = 0, rc; tlock_t *tlck; /* Transaction lock */ dtlock_t *dtlck; /* dtree line lock */ lv_t *lv; /* line lock vector */ // BEGIN F226941 #ifdef _JFS_OS2 int64 blocks_moving; /* Number of blocks being moved */ int64 orig_fromblocks; /* original dasd usage of from dir */ int64 orig_toblocks; /* original dasd usage of to dir */ uint32 start_here; /* index in limits array */ int32 i; inode_t *lock_arr[64]; /* Array of inodes to lock */ inode_t **lock_list; /* List of inodes to lock */ int32 num_locks; /* Number of inodes to lock */ int32 upper_limit; /* Upper limit to number of inodes * we need to lock */ #ifdef _JFS_FASTDASD int32 first_locked; /* index in lock_list array of first * inode still locked. D233382 */ #endif /* _JFS_FASTDASD */ #endif /* _JFS_OS2 */ // BEGIN F226941 assert( to_name != NULL && from_name != NULL); ipmnt = frompar_ip->i_ipmnt; RENAME_LOCK(ipmnt); /* * Make sure that we are not renaming the "." or ".." entries in * a directory. */ if (from_name[0] == '.' && (!from_name[1] || (from_name[1] == '.' && !from_name[2]))) { error = EINVAL; goto abortit; } /* * Now we want to verify the proper realationship between the inodes. * If everything checks out we need to obtain locks on the source parent * directory, destination parent directory, source, and destination * inodes. This allows us to proceed knowing that noone can delete * either the source or destination from underneath us. It also allows * us to know noone will be modifying the destination so we can delete * it safely. We need the lock on the source since we might need to * modify its .. entry. */ /* * In OS/2, the destination cannot exist unless it is the same as * the source. This is to allow DosMove to change the case of a * filename. */ if (to_ip && (from_ip != to_ip)) { error = EINVAL; goto abortit; } /* * Check for cross-device rename. */ if (frompar_ip->i_dev != topar_ip->i_dev) { error = EXDEV; goto abortit; } /* * Check if source is the destination parent. Can't do this * since this would orphan everything under the source. */ if (from_ip == topar_ip) { error = EINVAL; goto abortit; } /* * Now we know both the parents are okay. We will lock both the * parent inodes so we can guarantee the children will not be * deleted underneath us. We will also lock the source. * When locking the inodes we will use the protocol of locking * regular files first, then directories. When locking more than * one of each type, we do it in descending inode order. We also need * to make sure we don't attempt to lock one inode twice if the * two parents are the same. */ if ((from_ip->i_mode & IFMT) == IFDIR) doingdirectory = 1; // BEGIN F226941 if (from_dlim->num_limits) { /* We need to lock all directories from the root to each of * the from and to parent directories. The DASD usage lists * will contain at least one common entry (the root). We need * to compile a list of all unique inodes to lock. The upper * limit will be the sum of both num_limits fields. */ if (frompar_ip == topar_ip) upper_limit = from_dlim->num_limits + 1; else upper_limit = from_dlim->num_limits + to_dlim->num_limits; if (upper_limit > 64) lock_list = (inode_t **) xmalloc(upper_limit* sizeof(inode_t *), 0, kernel_heap); else lock_list = lock_arr; /* Put from parents dasd usage list into lock_list */ for (num_locks = 0; num_locks < from_dlim->num_limits; num_locks++) lock_list[num_locks] = from_dlim->pLimits[num_locks]; /* * We need to lock regular files before directories. If * we are moving a regular file, lock it now, otherwise add * it to the lock list. */ if (doingdirectory) lock_list[num_locks++] = from_ip; else IWRITE_LOCK(from_ip); if (frompar_ip != topar_ip) { /* Add unique members of to parent's dasd usage list */ for (i = 0; i < to_dlim->num_limits; i++) if (to_dlim->pLimits[i] != lock_list[i]) break; start_here = i; /* Needed by over_limit() */ while (i < to_dlim->num_limits) lock_list[num_locks++] = to_dlim->pLimits[i++]; } /* Lock them! */ sort_and_lock(0, num_locks, lock_list); /* * If this was a regular file, add the inode to the lock list * now, so we include it in the txCommit, and unlock it */ if (!doingdirectory) lock_list[num_locks++] = from_ip; from_dlim->flag |= DLIM_DIRS_LOCKED; frompar_ip->i_dasdlim = from_dlim; if (frompar_ip != topar_ip) // D230860 { to_dlim->flag |= DLIM_DIRS_LOCKED; topar_ip->i_dasdlim = to_dlim; } } else // END F226941 { if (doingdirectory) { if (frompar_ip == topar_ip) iwritelocklist(2, frompar_ip, from_ip); else iwritelocklist(3, frompar_ip, topar_ip, from_ip); } else { if (frompar_ip == topar_ip) { IWRITE_LOCK(from_ip); IWRITE_LOCK(frompar_ip); } else { IWRITE_LOCK(from_ip); iwritelocklist(2, frompar_ip, topar_ip); } } } /* * Now that we have the source parent locked we can lookup the * source inode to make sure it hasn't changed since we did our * initial verification. If it has we will need to release our * locks and repeat our verification with the new version. * Otherwise we know the source is valid and we can continue. */ dname.name = from_name; dname.namlen = UniStrlen (from_name); rc = dtSearch(frompar_ip, &dname, &ino, &btstack, JFS_LOOKUP); switch (rc) { case 0: /* * An entry was found, need to see if it is the * same inode as we had before. */ if (ino != from_ip->i_number) { rc = ENOENT; goto cleanup; } break; default: /* * Either the source cannot be found or * something went wrong in the search */ error = rc; goto cleanup; } /* * If changing case, no need to search for destination inode */ if (!to_ip) { /* * Now we can lookup the destination inode to make sure it * hasn't been created since we did our verifications. If it * has we abort. */ dname.name = to_name; dname.namlen = UniStrlen (to_name); if (dname.namlen > JFS_NAME_MAX-1) { error = ERROR_FILENAME_EXCED_RANGE; goto cleanup; } rc = dtSearch(topar_ip, &dname, &ino, &btstack, JFS_LOOKUP); switch (rc) { case 0: /* * We found an entry; fail with EEXIST */ rc = EEXIST; goto cleanup; case ENOENT: break; default: /* * Some error from dtSearch(). cleanup and * return */ error = rc; goto cleanup; } } /* * Now we need to validate parameters and check for proper inodes */ /* * Make sure the source inode has a positive link count */ if (from_ip->i_nlink <= 0) { error = EINVAL; goto cleanup; } if ((topar_ip->i_mode & IFMT) != IFDIR) { error = EINVAL; goto cleanup; } /* Check for the appropriate permissions on the source */ if (doingdirectory && (frompar_ip->i_number != topar_ip->i_number)) { /* * Account for ".." in new directory. When source and * destination have the same parent we don't fool with the link * count. */ if ((nlink_t)topar_ip->i_nlink >= LINK_MAX) { error = EMLINK; goto cleanup; } /* * If ".." must be changed (i.e. the directory gets a new * parent) then the source directory must not be in the * directory hierarchy above the target, as this would orphan * everything below the source directory. */ newparent = topar_ip->i_number; /* RENAME_LOCK(topar_ip->i_ipmnt); */ if (error = jfs_checkpath(from_ip, frompar_ip, topar_ip, vfst)) goto cleanup; } /* * Check for write-protected media */ if (isReadOnly(topar_ip)) { error = EROFS; goto cleanup; } // BEGIN F226941 /* * Check to see if there is room in the destination directory */ blocks_moving = doingdirectory ? DASDUSED(&from_ip->i_DASD) : from_ip->i_nblocks; if ((topar_ip != frompar_ip) && (topar_ip->i_dasdlim) && over_limit(topar_ip->i_dasdlim, blocks_moving, start_here)) { error = ERROR_DISK_FULL; goto cleanup; } orig_fromblocks = frompar_ip->i_nblocks; if (topar_ip != frompar_ip) orig_toblocks = topar_ip->i_nblocks; // END F226941 /* * Perform rename */ txBegin(topar_ip->i_ipmnt, &tid, 0); dname.name = to_name; dname.namlen = UniStrlen (to_name); if (to_ip != NULL) { /* * We change the case of the name in place. */ ino = to_ip->i_number; if (error = dtChangeCase(tid, frompar_ip, &dname, &ino, JFS_RENAME)) goto cleanup; imark(topar_ip, ICHG|IUPD|IFSYNC); } else { /* * We already know the destination does not exist, so link * source inode as destination. */ if (error = dtSearch(topar_ip, &dname, &ino, &btstack, JFS_CREATE)) { /* * Problem, can't find where to put this guy, or it * already exists!! */ goto cleanup; } ino = from_ip->i_number; if (error = dtInsert(tid, topar_ip, &dname, &ino, &btstack)) { /* * Failed adding source to destination parent */ goto cleanup; } imark(topar_ip, ICHG|IUPD|IFSYNC); /* Insert entry for the new file to name cache */ ncEnter(topar_ip->i_ipimap, topar_ip->i_number, &dname, from_ip->i_number, NULL); /* Remove source name from source parent and name cache */ dname.name = from_name; dname.namlen = UniStrlen (from_name); ino = from_ip->i_number; ncDelete(frompar_ip->i_ipimap, frompar_ip->i_number, &dname); if (error = dtDelete(tid, frompar_ip, &dname, &ino, JFS_REMOVE)) { /* * Another unexpected error -- the original file does not * appear to exist ... */ assert(0); } imark(frompar_ip, ICHG|IUPD|IFSYNC); /* * If this is a directory we need to update the ".." i-number * in the inode. Also, there is now one fewer ".." referencing * the source parent directory. Decrement the link count to * the source parent directory for this. */ if (doingdirectory && newparent) { /* linelock header of dtree root (containing idotdot) */ tlck = txLock(tid, from_ip, (jbuf_t *)&from_ip->i_bxflag, tlckDTREE|tlckBTROOT); dtlck = (dtlock_t *)&tlck->lock; ASSERT(dtlck->index == 0); lv = (lv_t *)&dtlck->lv[0]; lv->offset = 0; lv->length = 1; dtlck->index++; ((dtroot_t *) &from_ip->i_btroot)->header.idotdot = newparent; frompar_ip->i_nlink--; topar_ip->i_nlink++; /* RENAME_UNLOCK(topar_ip->i_ipmnt); */ } /* Set or reset INEWNAME flag as appropriate */ from_ip->i_mode = (from_ip->i_mode & ~INEWNAME) | (flags & INEWNAME); imark(from_ip, ICHG|IFSYNC); // D231252 txList[txCount++] = from_ip; // D231252 } // BEGIN F226941 /* * Modify dasd usage for source and destination directories. * Number of blocks for object being moved didn't change. */ if (frompar_ip == topar_ip) { DLIM_UPDATE(tid, frompar_ip, frompar_ip->i_nblocks - orig_fromblocks); } else { DLIM_UPDATE(tid, topar_ip, topar_ip->i_nblocks + blocks_moving - orig_toblocks); DLIM_UPDATE(tid, frompar_ip, frompar_ip->i_nblocks - (orig_fromblocks + blocks_moving)); } // BEGIN D233382 #ifdef _JFS_FASTDASD if (from_dlim->num_limits) { /* * Let's remove any ancestor directories at the beginning of * the lock list that aren't directly involved in the rename. * i_dasdlim will be non-zero for frompar_ip & topar_ip */ for(i = 0; i < num_locks; i++) { if (lock_list[i]->i_dasdlim) { first_locked = i; break; } IWRITE_UNLOCK(lock_list[i]); } ASSERT(i < num_locks); // We shouldn't have unlocked them all. } #endif /* _JFS_FASTDASD */ // END D233382 #ifndef _JFS_FASTDASD // D233382 if ((from_dlim->flag & DLIM_LOGGED) || (to_dlim->flag & DLIM_LOGGED)) { error = txCommit(tid, num_locks, lock_list, 0); from_dlim->flag &= ~DLIM_LOGGED; to_dlim->flag &= ~DLIM_LOGGED; } else #endif /* _JFS_FASTDASD */ // D233382 // END F226941 { if (frompar_ip != topar_ip) { /* * Different parent, so we need to add the other parent * to our transaction list */ txList[txCount++] = topar_ip; } /* Add source parent directory to transaction list */ txList[txCount++] = frompar_ip; assert(txCount <= 4); error = txCommit(tid, txCount, txList, 0); } cleanup: /* * Come to this label when all locks have been taken and ready to leave. * error should be set to return value. */ if (tid != -1) txEnd(tid); // BEGIN F226941 if (from_dlim->num_limits) { frompar_ip->i_dasdlim->flag &= ~DLIM_DIRS_LOCKED; frompar_ip->i_dasdlim = 0; if (frompar_ip != topar_ip) { topar_ip->i_dasdlim->flag &= ~DLIM_DIRS_LOCKED; topar_ip->i_dasdlim = 0; } #ifdef _JFS_FASTDASD for(i = first_locked; i < num_locks; i++) // D233382 #else for(i = 0; i < num_locks; i++) #endif IWRITE_UNLOCK(lock_list[i]); if (lock_list != lock_arr) xmfree((void *)lock_list, kernel_heap); } else // END F226941 { IWRITE_UNLOCK(from_ip); IWRITE_UNLOCK(frompar_ip); if (frompar_ip != topar_ip) { IWRITE_UNLOCK(topar_ip); } } abortit: /* * Come to this label when none of the locks have been taken and ready * to leave. error should be set to return value. */ if (to_ip && got_to) { ICACHE_LOCK(); iput(to_ip, vfst); ICACHE_UNLOCK(); } if (got_from) { ICACHE_LOCK(); iput(from_ip, vfsf); ICACHE_UNLOCK(); } RENAME_UNLOCK(ipmnt); return error; }
/* * NAME: readdir * * FUNCTION: read directory according to specifications * in directory search structure * * PARAMETER: * * RETURN: EINVAL - if not a directory * errors from subroutines * * note: * N.B. directory file offset encodes (directory page number, * entry index number), and shold NOT be interpreted/modified * by caller (lseek()) except that intial offset set to 0. * * no guarantees can be made that the exact offset * requested can be found if directory has been updated * by other threads between consecutive readdir()s. * transfer length of zero signals start offset beyond eof. * * unused space in the directory are not returned to the user, * i.e., more than requested size may have to be read * from directory to fill the user's buffer. */ readdir( struct vnode *dvp, /* inode of directory being read */ struct fsfd *fsfp, /* directory search information */ char *ubuf, /* user's data area */ uint32 ubytes, /* size of user's data area */ uint32 *matchcnt, /* count of entries returned */ uint32 level, /* level of output struct */ uint32 flags, /* offsets needed in output? */ EAOP *eaopp, /* pointer to EAOP */ struct ucred *crp) { int32 rc = 0; int32 ReturnCode = NO_ERROR; inode_t *dip; /* directory inode */ inode_t *ip; /* object inode */ uint32 matches; /* output matches found */ uint32 dtmatches; /* matches found per dtFind call */ uint32 position; /* offsets in output */ uint32 count; /* output buffer count */ int32 tbytes; /* byte count in dirent buffer */ struct dirent *dbuf; /* dirent buffer */ struct dirent *dbufp; /* dirent buffer */ uint32 ffhdsize; /* size of ffbuf header */ component_t lastmatch; /* pointer to last matching entry */ char *ffbuf; /* output buffer pointer */ char *nxbuf; /* output buffer pointer */ char *bufp; /* output buffer pointer */ MMPHPrereaddir(); /* MMPH Performance Hook */ /* set state from search structure */ dip = VP2IP(dvp); position = flags & FF_GETPOS; /* validate request */ if (ubytes == 0) { rc = EINVAL; goto readdir_Exit; } /* continuous read of empty directory ? */ if (fsfp->fsd_offset == -1) { rc = ERROR_NO_MORE_FILES; goto readdir_Exit; } dbuf = (struct dirent *)allocpool(dirent_pool, 0); // D228565 if (dbuf == 0) // D228565 { rc = ENOMEM; goto readdir_Exit; } /* set up variable to manipulate output buffer pointers * based on level. */ if (level == 1) ffhdsize = FFBUFHD; else if (level == 11) ffhdsize = FFBUFHD3L; else if (level < 11) ffhdsize = FFBUFHD2; else ffhdsize = FFBUFHD4L; if (position) ffhdsize += sizeof(uint32); ffbuf = ubuf; count = 0; matches = *matchcnt; *matchcnt = 0; while ((*matchcnt < matches) && (rc == 0)) { IREAD_LOCK(dip); /* directory became void when last link was removed */ if ((dip->i_nlink == 0) || ((dip->i_mode & IFMT) != IFDIR)) { IREAD_UNLOCK(dip); freepool(dirent_pool, (caddr_t *)dbuf); rc = ENOTDIR; goto readdir_Exit; } /* fill a directory buffer. * read on-disk structure (struct ldtentry_t) and * translate into readdir() structure (struct dirent). */ tbytes = 0; dtmatches = matches - *matchcnt; dbufp = dbuf; // D228565 rc = dtFind(dip, &fsfp->fsd_pattern, fsfp->fsd_lastmatch, &fsfp->fsd_offset, &dtmatches, PSIZE, &tbytes, dbufp); IREAD_UNLOCK(dip); if (rc) { freepool(dirent_pool, (caddr_t *)dbuf); goto readdir_Exit; } /* copy translate buffer to user FileFindBuf buffer */ while ((*matchcnt < matches) && (ReturnCode == NO_ERROR)) { uint32 namlen; /* translation buffer empty? */ if (tbytes == 0) break; /* get size of next name */ namlen = dbufp->d_namlen; /* user buffer full? * the +1 here is to allow for the null character * terminating the name string. */ if ((count + ffhdsize + namlen + 1) > ubytes) { rc = ERROR_BUFFER_OVERFLOW; break; } /* get the inode for the file */ ICACHE_LOCK(); rc = iget(dvp->v_vfsp, dbufp->d_ino, &ip, 0); ICACHE_UNLOCK(); if (rc) goto try_next; nxbuf = ffbuf; /* fill in file search info for files that have * the proper attributes; ignore others. */ rc = get_fileinfo(ip, &nxbuf, ubytes, dbufp->d_name, namlen, fsfp->fsd_havattr, level, eaopp, flags); if ((rc == ERROR_BUFFER_OVERFLOW) && (*matchcnt == 0) && ((level == FIL_QUERYEASFROMLIST) || (level == FIL_QUERYEASFROMLISTL))) { /* Can't fit EA in buffer, try without * getting EA */ if (level == FIL_QUERYEASFROMLIST) level = FIL_QUERYEASIZE; else level = FIL_QUERYEASIZEL; ReturnCode = ERROR_EAS_DIDNT_FIT; rc = get_fileinfo(ip, &nxbuf, ubytes, dbufp->d_name, namlen, fsfp->fsd_havattr, level, eaopp, flags); } /* release the inode */ jfs_rele(IP2VP(ip)); if (rc == 0) { /* set offset if requested */ if (position) { rc = KernCopyOut(ffbuf, &dbufp->d_offset, sizeof(int32)); if (rc) { /* This is very unlikely to * happen! */ ASSERT(0); break; } } /* update output buffer count */ count += nxbuf - ffbuf; /* move to next entry in output buffer */ ffbuf = nxbuf; /* update match count */ *matchcnt += 1; } else if (rc != -1) break; try_next: /* rc == -1 indicates no attribute match, * just keep going. */ rc = 0; /* save name for next call setup */ lastmatch.name = dbufp->d_name; lastmatch.namlen = namlen; /* update dirent buffer count */ tbytes -= dbufp->d_reclen; /* move to next entry in dirent buffer */ dbufp = (struct dirent *) ((caddr_t)dbufp + dbufp->d_reclen); } /* We don't want to continue if ReturnCode = ERROR_EAS_DIDNT_FIT */ if (rc == 0) rc = ReturnCode; /* set return code for end of directory with no matches */ if (fsfp->fsd_offset == -1) rc = ERROR_NO_MORE_FILES; else if ((rc == 0) || (rc == ERROR_EAS_DIDNT_FIT)) { /* save last matching name for next call */ UniStrncpy(fsfp->fsd_lastmatch,lastmatch.name, lastmatch.namlen); fsfp->fsd_lastmatch[lastmatch.namlen] = '\0'; } } /* claim success if we return any entries */ if (*matchcnt != 0) rc = ReturnCode; freepool(dirent_pool, (caddr_t *)dbuf); readdir_Exit: MMPHPostreaddir(); /* MMPH Performance Hook */ return rc; }
/* * NAME: jfs_mkdir(dvp, name, mode, crp) * * FUNCTION: create a child directory in the parent directory <dvp> * with name = <name> and mode = <mode> * * PARAMETER: dvp - parent directory vnode * name - name of child directory * mode - create mode (rwxrwxrwx). * crp - credential * * RETURN: Errors from subroutines * * note: * EACCESS: user needs search+write permission on the parent directory */ jfs_mkdir( struct vnode *dvp, UniChar *name, mode_t mode, #ifdef _JFS_OS2 EAOP *pEABuf, #endif /* _JFS_OS2 */ struct ucred *crp) { int32 rc = 0, rc1 = 0; int32 tid; /* transaction id */ struct vfs *vfsp = dvp->v_vfsp; inode_t *dip = VP2IP(dvp); /* parent directory inode */ struct dasd_usage *du; // F226941 inode_t *ip = NULL; /* child directory inode */ ino_t ino; component_t dname; /* child directory name */ btstack_t btstack; inode_t *iplist[2]; int64 orig_nblocks; // F226941 #ifdef _JFS_LAZYCOMMIT tblock_t *tblk; // D230860 #endif #ifdef _JFS_OS2 FEALIST *pfealist = NULL; #endif /* _JFS_OS2 */ NOISE(1,("jfs_mkdir: dip:0x%08x name:%s\n", dip, name)); /* * the named file exists for "." or ".." */ if (name[0] == '.') { if ((name[1] == '.' && name[2] == '\0') || name[1] == '\0') return EEXIST; } #ifdef _JFS_OS2 /* validate the EAOP buffer, FEALIST size storage location and the * entire FEALIST storage area. Once all the storage has been * validated, the entire FEALIST is validated for format and the size is * computed and compared against the limit. */ if (pEABuf) { if (rc = jfs_ValidateUserFEAList(pEABuf, &pfealist, &pEABuf->oError)) { /* something failed -- bail out */ return rc; } } #endif /* _JFS_OS2 */ if (dip->i_nlink == 0) { rc = ENOENT; goto out1; } /* link count overflow on parent directory ? */ if (dip->i_nlink >= LINK_MAX) { rc = EMLINK; goto out1; } /* * search parent directory for entry/freespace * (dtSearch() returns parent directory page pinned) */ dname.name = name; dname.namlen = UniStrlen(name); if (dname.namlen > JFS_NAME_MAX-1) { rc = ERROR_FILENAME_EXCED_RANGE; goto out1; } // BEGIN D233382 #ifdef _JFS_LAZYCOMMIT if (isReadOnly(dip)) { rc = EROFS; goto out1; } /* * Either iAlloc() or txBegin() may block. Deadlock can occur if we * block there while holding dtree page, so we allocate the inode & * begin the transaction before we search the directory. */ if (rc = iAlloc(vfsp, dip, IFDIR|mode|IDIRECTORY, &ip, crp)) goto out1; txBegin(dip->i_ipmnt, &tid, 0); if (rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE)) { ip->i_nlink = 0; ICACHE_LOCK(); iput(ip, vfsp); ICACHE_UNLOCK(); txEnd(tid); goto out1; } tblk = &TxBlock[tid]; // D230860 tblk->xflag |= COMMIT_CREATE; // D230860 tblk->ip = ip; // D230860 #else /* ! _JFS_LAZYCOMMIT */ // END D233382 if (rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE)) goto out1; if (isReadOnly(dip)) { rc = EROFS; /* release parent directory page */ BT_PUTSEARCH(&btstack); goto out1; } /* * allocate on-disk/in-memory inode for child directory: * (iAlloc() returns new, locked inode) */ if (rc = iAlloc(vfsp, dip, IFDIR|mode|IDIRECTORY, &ip, crp)) { /* release parent directory page */ BT_PUTSEARCH(&btstack); jEVENT(0,("jfs_mkdir: iAlloc error(%d)\n", rc)); goto out1; } txBegin(dip->i_ipmnt, &tid, 0); #endif /* _JFS_LAZYCOMMIT */ du = ip->i_dasdlim = dip->i_dasdlim; // F226941 orig_nblocks = dip->i_nblocks; // F226941 iplist[0] = dip; iplist[1] = ip; /* * initialize the child directory in-line in inode */ dtInitRoot(tid, ip, dip->i_number); /* * create entry in parent directory for child directory * (dtInsert() releases parent directory page) */ ino = ip->i_number; if (rc = dtInsert(tid, dip, &dname, &ino, &btstack)) { /* discard new directory inode */ ip->i_nlink = 0; if (rc == EIO) txAbort(tid, 1); /* Marks Filesystem dirty */ else txAbort(tid, 0); /* Filesystem full */ txEnd(tid); goto out3; } /* update child directory inode */ // BEGIN F226941 setDASDLIMIT(&ip->i_DASD, 0); setDASDUSED(&ip->i_DASD, 0); // END F226941 ip->i_nlink++; /* for '.' */ imark(ip, IACC|ICHG|IUPD|IFSYNC); /* update parent directory inode */ dip->i_nlink++; /* for '..' from child directory */ imark(dip, ICHG|IUPD|IFSYNC); /* * insert entry for the new file to dnlc */ ncEnter(dip->i_ipimap, dip->i_number, &dname, ino, NULL); #ifdef _JFS_OS2 if ((rc1 == 0) && pfealist) // F226941 rc1 = jfs_InitializeFEAList(ip, tid, pfealist); if ((rc1 == 0) && (dip->i_acl.flag) && (dip->i_acl.size)) rc1 = jfs_CopyACL(ip, dip, tid); #endif /* _JFS_OS2 */ // BEGIN FF226941 DLIM_UPDATE(tid, dip, dip->i_nblocks + ip->i_nblocks - orig_nblocks); setDASDUSED(&ip->i_DASD, ip->i_nblocks); // D233382 #ifndef _JFS_FASTDASD // D233382 /* * If the transaction modified the ancestors of the inode, the * parent will be in the dasd usage list. Otherwise, transaction * will only change new directory and parent. */ if (du && (du->flag & DLIM_LOGGED)) rc = dasd_commit(tid, ip, 0); else #endif /* _JFS_FASTDASD */ // D233382 // END FF226941 rc = txCommit(tid, 2, &iplist[0], 0); txEnd(tid); #ifdef _JFS_OS2 /* If we successfully added the directory, but failed adding the EA or * ACL, we must cleanup the created directory entry and return the * error. */ if (rc1) { // BEGIN D230860 if ((du) && (du->first_locked)) { /* * txCommit unlocked one or more inodes. * We need to unlock all the directories & * relock them. */ dip->i_dasdlim = 0; DLIM_WRITE_UNLOCK_DETACH(ip, du); DLIM_WRITE_LOCK_ATTACH(ip, du); dip->i_dasdlim = du; } // END D230860 jfs_xrmdir(dip, ip, name); rc = rc1; } #endif /* _JFS_OS2 */ out3: ip->i_dasdlim = 0; // F226941 IWRITE_UNLOCK(ip); ICACHE_LOCK(); iput(ip, vfsp); ICACHE_UNLOCK(); out1: #ifdef _JFS_OS2 /* * this buffer was allocated by * jfs_ValidateUserFEAList() at twice the * size of the given list to provide buffer * space for eliminating duplicate names */ if (pfealist) jfs_EABufFree((char *)pfealist, (pfealist->cbList << 1)); #endif /* _JFS_OS2 */ NOISE(1,("jfs_mkdir: rc:%d\n", rc)); return rc; }
/* * NAME: jfs_defragfs() * * FUNCTION: relocate specified extent for defragfs() * optionally commiting the operation. */ int32 jfs_defragfs( char *pData, /* pointer to buffer containing plist */ uint32 lenData, /* length of buffer */ uint16 *pbufsize) /* pointer of buffer length */ { int32 rc = 0; defragfs_t pList, *p = &pList; uint32 xtype; int64 offset, xoff, oxaddr, nxaddr; int32 xlen; inode_t *ipmnt, *ipimap, *ipbmap; inode_t *ip = NULL; xad_t oxad; pxd_t opxd; mode_t imode; int32 tid; inode_t *iplist[1]; struct vfs *vfsp; if (rc = KernCopyIn(&pList, pData, lenData)) return rc; /* get the 'mount' inode */ for (vfsp = vfs_anchor; vfsp != NULL; vfsp = vfsp->vfs_next) if (vfsp->vfs_vpfsi->vpi_drive == pList.dev) break; if (vfsp == NULL) return EINVAL; xtype = pList.flag; /* sync at start of defragfs ? */ if (xtype & DEFRAGFS_SYNC) { jEVENT(0,("jfs_defragfs: DEFRAGFS_SYNC\n")); if ((vfsp->vfs_flag & VFS_READONLY) || (vfsp->vfs_flag & VFS_ACCEPT)) return 0; ipimap = (inode_t *)vfsp->vfs_data; ipmnt = ipimap->i_ipmnt; ipbmap = ipmnt->i_ipbmap; /* sync the file system */ iSyncFS(vfsp); /* write dirty pages of imap */ diSync(ipimap); /* write dirty pages of bmap */ dbSync(ipbmap); return 0; } else if (!(xtype & DEFRAGFS_RELOCATE)) return EINVAL; if (vfsp->vfs_flag & VFS_READONLY) return EROFS; if (vfsp->vfs_flag & VFS_ACCEPT) return EINVAL; /* get the relocation parameter */ xoff = pList.xoff; oxaddr = pList.old_xaddr; nxaddr = pList.new_xaddr; xlen = pList.xlen; jEVENT(0,("jfs_defragfs: i:%d xtype:0x%08x xoff:%lld xlen:%d xaddr:%lld:%lld\n", pList.ino, xtype, xoff, xlen, oxaddr, nxaddr)); /* get the object inode if it exist */ ICACHE_LOCK(); rc = iget(vfsp, pList.ino, &ip, 0); ICACHE_UNLOCK(); if(rc) { jEVENT(0,("jfs_defragfs: stale target object.\n")); rc = ESTALE; /* stale object ENOENT */ goto out1; } IWRITE_LOCK(ip); /* validate inode */ if (ip->i_nlink == 0 || ip->i_gen != pList.gen || ip->i_fileset != pList.fileset || ip->i_inostamp != pList.inostamp) { jEVENT(0,("jfs_defragfs: stale target object.\n")); rc = ESTALE; /* stale object ENOENT */ goto out1; } /* validate object type: regular file or directory */ imode = ip->i_mode & IFMT; switch(imode) { case IFREG: case IFDIR: break; default: rc = ESTALE; /* invalid object type ENOENT */ goto out1; } /* * try to allocate new destination extent */ if (rc = dbAllocExact(ip, nxaddr, xlen)) { jEVENT(0,("jfs_defragfs: stale destination extent.\n")); rc = ENOSPC; goto out1; } iBindCache(ip); /* * regular file: */ if (imode == IFREG) { /* * automatic commit before and after each relocation * may be skipped after more experience; */ /* * commit any update before relocation */ if (ip->i_flag & IUPD) { ip->i_flag |= IFSYNC; txBegin(ip->i_ipmnt, &tid, 0); iplist[0] = ip; rc = txCommit(tid, 1, &iplist[0], 0); if (rc) goto out2; txEnd(tid); } /* * relocate either xtpage or data extent */ txBegin(ip->i_ipmnt, &tid, 0); /* source extent xad */ XADoffset(&oxad, xoff); XADaddress(&oxad, oxaddr); XADlength(&oxad, xlen); rc = xtRelocate(tid, ip, &oxad, nxaddr, xtype); if (rc) goto out2; iplist[0] = ip; rc = txCommit(tid, 1, &iplist[0], 0); if (rc) goto out2; txEnd(tid); goto out1; } /* * directory: */ else /* IFDIR */ { /* * relocate dtpage */ txBegin(ip->i_ipmnt, &tid, 0); /* source extent pxd */ PXDaddress(&opxd, oxaddr); PXDlength(&opxd, xlen); rc = dtRelocate(tid, ip, xoff, &opxd, nxaddr); if (rc) goto out2; iplist[0] = ip; rc = txCommit(tid, 1, &iplist[0], 0); if (rc) goto out2; txEnd(tid); goto out1; } out2: dbFree(ip, nxaddr, xlen) ; out1: if (ip) { IWRITE_UNLOCK(ip); ICACHE_LOCK(); iput(ip, NULL); ICACHE_UNLOCK(); } jEVENT(0,("jfs_defragfs: rc=%d\n", rc)); return (rc); }