/*
* Create a new inode in the specified directory using the vattr to
* figure out the type of inode.
*
* If no error occurs the new inode with its chain locked is returned in
* *nipp, otherwise an error is returned and *nipp is set to NULL.
*
* If vap and/or cred are NULL the related fields are not set and the
* inode type defaults to a directory. This is used when creating PFSs
* under the super-root, so the inode number is set to 1 in this case.
*
* dip is not locked on entry.
*/
hammer2_inode_t *
hammer2_inode_create(hammer2_trans_t *trans, hammer2_inode_t *dip,
struct vattr *vap, struct ucred *cred,
const uint8_t *name, size_t name_len,
hammer2_chain_t **chainp, int *errorp)
{
hammer2_inode_data_t *dipdata;
hammer2_inode_data_t *nipdata;
hammer2_chain_t *chain;
hammer2_chain_t *parent;
hammer2_inode_t *nip;
hammer2_key_t key_dummy;
hammer2_key_t lhc;
int error;
uid_t xuid;
uuid_t dip_uid;
uuid_t dip_gid;
uint32_t dip_mode;
uint8_t dip_algo;
int cache_index = -1;
lhc = hammer2_dirhash(name, name_len);
*errorp = 0;
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*
* NOTE: hidden inodes do not have iterators.
*/
retry:
parent = hammer2_inode_lock_ex(dip);
dipdata = &dip->chain->data->ipdata;
dip_uid = dipdata->uid;
dip_gid = dipdata->gid;
dip_mode = dipdata->mode;
dip_algo = dipdata->comp_algo;
error = 0;
while (error == 0) {
chain = hammer2_chain_lookup(&parent, &key_dummy,
lhc, lhc, &cache_index, 0);
if (chain == NULL)
break;
if ((lhc & HAMMER2_DIRHASH_VISIBLE) == 0)
error = ENOSPC;
if ((lhc & HAMMER2_DIRHASH_LOMASK) == HAMMER2_DIRHASH_LOMASK)
error = ENOSPC;
hammer2_chain_unlock(chain);
chain = NULL;
++lhc;
}
if (error == 0) {
error = hammer2_chain_create(trans, &parent, &chain,
lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
}
/*
* Cleanup and handle retries.
*/
if (error == EAGAIN) {
hammer2_chain_ref(parent);
hammer2_inode_unlock_ex(dip, parent);
hammer2_chain_wait(parent);
hammer2_chain_drop(parent);
goto retry;
}
hammer2_inode_unlock_ex(dip, parent);
if (error) {
KKASSERT(chain == NULL);
*errorp = error;
return (NULL);
}
/*
* Set up the new inode.
*
* NOTE: *_get() integrates chain's lock into the inode lock.
*
* NOTE: Only one new inode can currently be created per
* transaction. If the need arises we can adjust
* hammer2_trans_init() to allow more.
*
* NOTE: nipdata will have chain's blockset data.
*/
chain->data->ipdata.inum = trans->inode_tid;
nip = hammer2_inode_get(dip->pmp, dip, chain);
nipdata = &chain->data->ipdata;
if (vap) {
KKASSERT(trans->inodes_created == 0);
nipdata->type = hammer2_get_obj_type(vap->va_type);
nipdata->inum = trans->inode_tid;
++trans->inodes_created;
switch (nipdata->type) {
case HAMMER2_OBJTYPE_CDEV:
case HAMMER2_OBJTYPE_BDEV:
nipdata->rmajor = vap->va_rmajor;
nipdata->rminor = vap->va_rminor;
break;
default:
break;
}
} else {
nipdata->type = HAMMER2_OBJTYPE_DIRECTORY;
nipdata->inum = 1;
}
/* Inherit parent's inode compression mode. */
nip->comp_heuristic = 0;
nipdata->comp_algo = dip_algo;
nipdata->version = HAMMER2_INODE_VERSION_ONE;
hammer2_update_time(&nipdata->ctime);
nipdata->mtime = nipdata->ctime;
if (vap)
nipdata->mode = vap->va_mode;
nipdata->nlinks = 1;
if (vap) {
if (dip && dip->pmp) {
xuid = hammer2_to_unix_xid(&dip_uid);
xuid = vop_helper_create_uid(dip->pmp->mp,
dip_mode,
xuid,
cred,
&vap->va_mode);
} else {
/* super-root has no dip and/or pmp */
xuid = 0;
}
if (vap->va_vaflags & VA_UID_UUID_VALID)
nipdata->uid = vap->va_uid_uuid;
else if (vap->va_uid != (uid_t)VNOVAL)
hammer2_guid_to_uuid(&nipdata->uid, vap->va_uid);
else
hammer2_guid_to_uuid(&nipdata->uid, xuid);
if (vap->va_vaflags & VA_GID_UUID_VALID)
nipdata->gid = vap->va_gid_uuid;
else if (vap->va_gid != (gid_t)VNOVAL)
hammer2_guid_to_uuid(&nipdata->gid, vap->va_gid);
else if (dip)
nipdata->gid = dip_gid;
}
/*
* Regular files and softlinks allow a small amount of data to be
* directly embedded in the inode. This flag will be cleared if
* the size is extended past the embedded limit.
*/
if (nipdata->type == HAMMER2_OBJTYPE_REGFILE ||
nipdata->type == HAMMER2_OBJTYPE_SOFTLINK) {
nipdata->op_flags |= HAMMER2_OPFLAG_DIRECTDATA;
}
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, nipdata->filename, name_len);
nipdata->name_key = lhc;
nipdata->name_len = name_len;
*chainp = chain;
return (nip);
}
/*
* Connect the target inode represented by (*chainp) to the media topology
* at (dip, name, len). The caller can pass a rough *chainp, this function
* will issue lookup()s to position the parent chain properly for the
* chain insertion.
*
* If hlink is TRUE this function creates an OBJTYPE_HARDLINK directory
* entry instead of connecting (*chainp).
*
* If hlink is FALSE this function uses chain_duplicate() to make a copy
* if (*chainp) in the directory entry. (*chainp) is likely to be deleted
* by the caller in this case (e.g. rename).
*/
int
hammer2_inode_connect(hammer2_trans_t *trans,
hammer2_chain_t **chainp, int hlink,
hammer2_inode_t *dip, hammer2_chain_t **dchainp,
const uint8_t *name, size_t name_len,
hammer2_key_t lhc)
{
hammer2_inode_data_t *ipdata;
hammer2_chain_t *nchain;
hammer2_chain_t *ochain;
hammer2_key_t key_dummy;
int cache_index = -1;
int error;
/*
* Since ochain is either disconnected from the topology or represents
* a hardlink terminus which is always a parent of or equal to dip,
* we should be able to safely lock dip->chain for our setup.
*
* WARNING! Must use inode_lock_ex() on dip to handle a stale
* dip->chain cache.
*/
ochain = *chainp;
/*
* If name is non-NULL we calculate lhc, else we use the passed-in
* lhc.
*/
if (name) {
lhc = hammer2_dirhash(name, name_len);
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*/
error = 0;
while (error == 0) {
nchain = hammer2_chain_lookup(dchainp, &key_dummy,
lhc, lhc,
&cache_index, 0);
if (nchain == NULL)
break;
if ((lhc & HAMMER2_DIRHASH_LOMASK) ==
HAMMER2_DIRHASH_LOMASK) {
error = ENOSPC;
}
hammer2_chain_unlock(nchain);
nchain = NULL;
++lhc;
}
} else {
/*
* Reconnect to specific key (used when moving
* unlinked-but-open files into the hidden directory).
*/
nchain = hammer2_chain_lookup(dchainp, &key_dummy,
lhc, lhc, &cache_index, 0);
KKASSERT(nchain == NULL);
}
if (error == 0) {
if (hlink) {
/*
* Hardlink pointer needed, create totally fresh
* directory entry.
*
* We must refactor ochain because it might have
* been shifted into an indirect chain by the
* create.
*/
KKASSERT(nchain == NULL);
error = hammer2_chain_create(trans, dchainp, &nchain,
lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
hammer2_chain_refactor(&ochain);
} else {
/*
* Reconnect the original chain and rename. Use
* chain_duplicate(). The caller will likely delete
* or has already deleted the original chain in
* this case.
*
* NOTE: chain_duplicate() generates a new chain
* with CHAIN_DELETED cleared (ochain typically
* has it set from the file unlink).
*
* WARNING! Can cause held-over chains to require a
* refactor. Fortunately we have none (our
* locked chains are passed into and
* modified by the call).
*/
nchain = ochain;
ochain = NULL;
hammer2_chain_duplicate(trans, NULL, &nchain, NULL,
0, 3);
error = hammer2_chain_create(trans, dchainp, &nchain,
lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
}
}
/*
* Unlock stuff.
*/
KKASSERT(error != EAGAIN);
/*
* nchain should be NULL on error, leave ochain (== *chainp) alone.
*/
if (error) {
KKASSERT(nchain == NULL);
return (error);
}
/*
* Directory entries are inodes so if the name has changed we have
* to update the inode.
*
* When creating an OBJTYPE_HARDLINK entry remember to unlock the
* chain, the caller will access the hardlink via the actual hardlink
* target file and not the hardlink pointer entry, so we must still
* return ochain.
*/
if (hlink && hammer2_hardlink_enable >= 0) {
/*
* Create the HARDLINK pointer. oip represents the hardlink
* target in this situation.
*
* We will return ochain (the hardlink target).
*/
hammer2_chain_modify(trans, &nchain, 0);
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
ipdata = &nchain->data->ipdata;
bcopy(name, ipdata->filename, name_len);
ipdata->name_key = lhc;
ipdata->name_len = name_len;
ipdata->target_type = ochain->data->ipdata.type;
ipdata->type = HAMMER2_OBJTYPE_HARDLINK;
ipdata->inum = ochain->data->ipdata.inum;
ipdata->nlinks = 1;
hammer2_chain_unlock(nchain);
nchain = ochain;
ochain = NULL;
} else if (hlink && hammer2_hardlink_enable < 0) {
/*
* Create a snapshot (hardlink fake mode for debugging).
* (ochain already flushed above so we can just copy the
* bref XXX).
*
* Since this is a snapshot we return nchain in the fake
* hardlink case.
*/
hammer2_chain_modify(trans, &nchain, 0);
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
ipdata = &nchain->data->ipdata;
*ipdata = ochain->data->ipdata;
bcopy(name, ipdata->filename, name_len);
ipdata->name_key = lhc;
ipdata->name_len = name_len;
atomic_clear_int(&nchain->core->flags,
HAMMER2_CORE_COUNTEDBREFS);
kprintf("created fake hardlink %*.*s\n",
(int)name_len, (int)name_len, name);
} else {
/*
* nchain is a duplicate of ochain at the new location.
* We must fixup the name stored in oip. The bref key
* has already been set up.
*/
hammer2_chain_modify(trans, &nchain, 0);
ipdata = &nchain->data->ipdata;
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, ipdata->filename, name_len);
ipdata->name_key = lhc;
ipdata->name_len = name_len;
ipdata->nlinks = 1;
}
/*
* We are replacing ochain with nchain, unlock ochain. In the
* case where ochain is left unchanged the code above sets
* nchain to ochain and ochain to NULL, resulting in a NOP here.
*/
if (ochain)
hammer2_chain_unlock(ochain);
*chainp = nchain;
return (0);
}
/*
* Find a specific PFS by name
*/
static int
hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
{
const hammer2_inode_data_t *ripdata;
hammer2_dev_t *hmp;
hammer2_ioc_pfs_t *pfs;
hammer2_chain_t *parent;
hammer2_chain_t *chain;
hammer2_key_t key_next;
hammer2_key_t lhc;
int cache_index = -1;
int error;
size_t len;
hmp = ip->pmp->pfs_hmps[0];
if (hmp == NULL)
return (EINVAL);
pfs = data;
error = 0;
hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_SHARED);
parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
HAMMER2_RESOLVE_ALWAYS |
HAMMER2_RESOLVE_SHARED);
pfs->name[sizeof(pfs->name) - 1] = 0;
len = strlen(pfs->name);
lhc = hammer2_dirhash(pfs->name, len);
chain = hammer2_chain_lookup(&parent, &key_next,
lhc, lhc + HAMMER2_DIRHASH_LOMASK,
&cache_index,
HAMMER2_LOOKUP_SHARED);
while (chain) {
if (chain->bref.type == HAMMER2_BREF_TYPE_INODE) {
ripdata = &chain->data->ipdata;
if (ripdata->meta.name_len == len &&
bcmp(ripdata->filename, pfs->name, len) == 0) {
break;
}
ripdata = NULL; /* safety */
}
chain = hammer2_chain_next(&parent, chain, &key_next,
key_next,
lhc + HAMMER2_DIRHASH_LOMASK,
&cache_index,
HAMMER2_LOOKUP_SHARED);
}
/*
* Load the data being returned by the ioctl.
*/
if (chain) {
ripdata = &chain->data->ipdata;
pfs->name_key = ripdata->meta.name_key;
pfs->pfs_type = ripdata->meta.pfs_type;
pfs->pfs_subtype = ripdata->meta.pfs_subtype;
pfs->pfs_clid = ripdata->meta.pfs_clid;
pfs->pfs_fsid = ripdata->meta.pfs_fsid;
ripdata = NULL;
hammer2_chain_unlock(chain);
hammer2_chain_drop(chain);
} else {
error = ENOENT;
}
if (parent) {
hammer2_chain_unlock(parent);
hammer2_chain_drop(parent);
}
hammer2_inode_unlock(hmp->spmp->iroot);
return (error);
}
/*
* Unlink the file from the specified directory inode. The directory inode
* does not need to be locked.
*
* isdir determines whether a directory/non-directory check should be made.
* No check is made if isdir is set to -1.
*
* isopen specifies whether special unlink-with-open-descriptor handling
* must be performed. If set to -1 the caller is deleting a PFS and we
* check whether the chain is mounted or not (chain->pmp != NULL). 1 is
* implied if it is mounted.
*
* If isopen is 1 and nlinks drops to 0 this function must move the chain
* to a special hidden directory until last-close occurs on the file.
*
* NOTE! The underlying file can still be active with open descriptors
* or if the chain is being manually held (e.g. for rename).
*
* The caller is responsible for fixing up ip->chain if e.g. a
* rename occurs (see chain_duplicate()).
*/
int
hammer2_unlink_file(hammer2_trans_t *trans, hammer2_inode_t *dip,
const uint8_t *name, size_t name_len,
int isdir, int *hlinkp, struct nchandle *nch)
{
hammer2_inode_data_t *ipdata;
hammer2_chain_t *parent;
hammer2_chain_t *ochain;
hammer2_chain_t *chain;
hammer2_chain_t *dparent;
hammer2_chain_t *dchain;
hammer2_key_t key_dummy;
hammer2_key_t key_next;
hammer2_key_t lhc;
int error;
int cache_index = -1;
uint8_t type;
error = 0;
ochain = NULL;
lhc = hammer2_dirhash(name, name_len);
/*
* Search for the filename in the directory
*/
if (hlinkp)
*hlinkp = 0;
parent = hammer2_inode_lock_ex(dip);
chain = hammer2_chain_lookup(&parent, &key_next,
lhc, lhc + HAMMER2_DIRHASH_LOMASK,
&cache_index, 0);
while (chain) {
if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
name_len == chain->data->ipdata.name_len &&
bcmp(name, chain->data->ipdata.filename, name_len) == 0) {
break;
}
chain = hammer2_chain_next(&parent, chain, &key_next,
key_next,
lhc + HAMMER2_DIRHASH_LOMASK,
&cache_index, 0);
}
hammer2_inode_unlock_ex(dip, NULL); /* retain parent */
/*
* Not found or wrong type (isdir < 0 disables the type check).
* If a hardlink pointer, type checks use the hardlink target.
*/
if (chain == NULL) {
error = ENOENT;
goto done;
}
if ((type = chain->data->ipdata.type) == HAMMER2_OBJTYPE_HARDLINK) {
if (hlinkp)
*hlinkp = 1;
type = chain->data->ipdata.target_type;
}
if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 0) {
error = ENOTDIR;
goto done;
}
if (type != HAMMER2_OBJTYPE_DIRECTORY && isdir >= 1) {
error = EISDIR;
goto done;
}
/*
* Hardlink must be resolved. We can't hold the parent locked
* while we do this or we could deadlock.
*
* On success chain will be adjusted to point at the hardlink target
* and ochain will point to the hardlink pointer in the original
* directory. Otherwise chain remains pointing to the original.
*/
if (chain->data->ipdata.type == HAMMER2_OBJTYPE_HARDLINK) {
hammer2_chain_unlock(parent);
parent = NULL;
error = hammer2_hardlink_find(dip, &chain, &ochain);
}
/*
* If this is a directory the directory must be empty. However, if
* isdir < 0 we are doing a rename and the directory does not have
* to be empty, and if isdir > 1 we are deleting a PFS/snapshot
* and the directory does not have to be empty.
*
* NOTE: We check the full key range here which covers both visible
* and invisible entries. Theoretically there should be no
* invisible (hardlink target) entries if there are no visible
* entries.
*/
if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 1) {
dparent = hammer2_chain_lookup_init(chain, 0);
dchain = hammer2_chain_lookup(&dparent, &key_dummy,
0, (hammer2_key_t)-1,
&cache_index,
HAMMER2_LOOKUP_NODATA);
if (dchain) {
hammer2_chain_unlock(dchain);
hammer2_chain_lookup_done(dparent);
error = ENOTEMPTY;
goto done;
}
hammer2_chain_lookup_done(dparent);
dparent = NULL;
/* dchain NULL */
}
/*
* Ok, we can now unlink the chain. We always decrement nlinks even
* if the entry can be deleted in case someone has the file open and
* does an fstat().
*
* The chain itself will no longer be in the on-media topology but
* can still be flushed to the media (e.g. if an open descriptor
* remains). When the last vnode/ip ref goes away the chain will
* be marked unmodified, avoiding any further (now unnecesary) I/O.
*
* A non-NULL ochain indicates a hardlink.
*/
if (ochain) {
/*
* Delete the original hardlink pointer unconditionally.
* (any open descriptors will migrate to the hardlink
* target and have no affect on this operation).
*
* NOTE: parent from above is NULL when ochain != NULL
* so we can reuse it.
*/
hammer2_chain_lock(ochain, HAMMER2_RESOLVE_ALWAYS);
hammer2_chain_delete(trans, ochain, 0);
hammer2_chain_unlock(ochain);
}
/*
* Decrement nlinks on the hardlink target (or original file if
* there it was not hardlinked). Delete the target when nlinks
* reaches 0 with special handling if (isopen) is set.
*
* NOTE! In DragonFly the vnops function calls cache_unlink() after
* calling us here to clean out the namecache association,
* (which does not represent a ref for the open-test), and to
* force finalization of the vnode if/when the last ref gets
* dropped.
*
* NOTE! Files are unlinked by rename and then relinked. nch will be
* passed as NULL in this situation. hammer2_inode_connect()
* will bump nlinks.
*/
KKASSERT(chain != NULL);
hammer2_chain_modify(trans, &chain, 0);
ipdata = &chain->data->ipdata;
--ipdata->nlinks;
if ((int64_t)ipdata->nlinks < 0) /* XXX debugging */
ipdata->nlinks = 0;
if (ipdata->nlinks == 0) {
if ((chain->flags & HAMMER2_CHAIN_PFSROOT) && chain->pmp) {
error = EINVAL;
kprintf("hammer2: PFS \"%s\" cannot be deleted "
"while still mounted\n",
ipdata->filename);
goto done;
}
if (nch && cache_isopen(nch)) {
kprintf("WARNING: unlinking open file\n");
atomic_set_int(&chain->flags, HAMMER2_CHAIN_UNLINKED);
hammer2_inode_move_to_hidden(trans, &chain,
ipdata->inum);
} else {
hammer2_chain_delete(trans, chain, 0);
}
}
error = 0;
done:
if (chain)
hammer2_chain_unlock(chain);
if (parent)
hammer2_chain_lookup_done(parent);
if (ochain)
hammer2_chain_drop(ochain);
return error;
}
/*
* Unlink the file from the specified directory inode. The directory inode
* does not need to be locked.
*
* isdir determines whether a directory/non-directory check should be made.
* No check is made if isdir is set to -1.
*
* NOTE! This function does not prevent the underlying file from still
* being used if it has other refs (such as from an inode, or if it's
* chain is manually held). However, the caller is responsible for
* fixing up ip->chain if e.g. a rename occurs (see chain_duplicate()).
*/
int
hammer2_unlink_file(hammer2_trans_t *trans, hammer2_inode_t *dip,
const uint8_t *name, size_t name_len,
int isdir, int *hlinkp)
{
hammer2_inode_data_t *ipdata;
hammer2_chain_t *parent;
hammer2_chain_t *ochain;
hammer2_chain_t *chain;
hammer2_chain_t *dparent;
hammer2_chain_t *dchain;
hammer2_key_t lhc;
int error;
uint8_t type;
error = 0;
ochain = NULL;
lhc = hammer2_dirhash(name, name_len);
/*
* Search for the filename in the directory
*/
if (hlinkp)
*hlinkp = 0;
parent = hammer2_inode_lock_ex(dip);
chain = hammer2_chain_lookup(&parent,
lhc, lhc + HAMMER2_DIRHASH_LOMASK,
0);
while (chain) {
if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
name_len == chain->data->ipdata.name_len &&
bcmp(name, chain->data->ipdata.filename, name_len) == 0) {
break;
}
chain = hammer2_chain_next(&parent, chain,
lhc, lhc + HAMMER2_DIRHASH_LOMASK,
0);
}
hammer2_inode_unlock_ex(dip, NULL); /* retain parent */
/*
* Not found or wrong type (isdir < 0 disables the type check).
* If a hardlink pointer, type checks use the hardlink target.
*/
if (chain == NULL) {
error = ENOENT;
goto done;
}
if ((type = chain->data->ipdata.type) == HAMMER2_OBJTYPE_HARDLINK) {
if (hlinkp)
*hlinkp = 1;
type = chain->data->ipdata.target_type;
}
if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 0) {
error = ENOTDIR;
goto done;
}
if (type != HAMMER2_OBJTYPE_DIRECTORY && isdir >= 1) {
error = EISDIR;
goto done;
}
/*
* Hardlink must be resolved. We can't hold parent locked while we
* do this or we could deadlock.
*
* On success chain will be adjusted to point at the hardlink target
* and ochain will point to the hardlink pointer in the original
* directory. Otherwise chain remains pointing to the original.
*/
if (chain->data->ipdata.type == HAMMER2_OBJTYPE_HARDLINK) {
hammer2_chain_unlock(parent);
parent = NULL;
error = hammer2_hardlink_find(dip, &chain, &ochain);
}
/*
* If this is a directory the directory must be empty. However, if
* isdir < 0 we are doing a rename and the directory does not have
* to be empty, and if isdir > 1 we are deleting a PFS/snapshot
* and the directory does not have to be empty.
*
* NOTE: We check the full key range here which covers both visible
* and invisible entries. Theoretically there should be no
* invisible (hardlink target) entries if there are no visible
* entries.
*/
if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 1) {
dparent = hammer2_chain_lookup_init(chain, 0);
dchain = hammer2_chain_lookup(&dparent,
0, (hammer2_key_t)-1,
HAMMER2_LOOKUP_NODATA);
if (dchain) {
hammer2_chain_unlock(dchain);
hammer2_chain_lookup_done(dparent);
error = ENOTEMPTY;
goto done;
}
hammer2_chain_lookup_done(dparent);
dparent = NULL;
/* dchain NULL */
}
/*
* Ok, we can now unlink the chain. We always decrement nlinks even
* if the entry can be deleted in case someone has the file open and
* does an fstat().
*
* The chain itself will no longer be in the on-media topology but
* can still be flushed to the media (e.g. if an open descriptor
* remains). When the last vnode/ip ref goes away the chain will
* be marked unmodified, avoiding any further (now unnecesary) I/O.
*
* A non-NULL ochain indicates a hardlink.
*/
if (ochain) {
/*
* Delete the original hardlink pointer.
*
* NOTE: parent from above is NULL when ochain != NULL
* so we can reuse it.
*/
hammer2_chain_lock(ochain, HAMMER2_RESOLVE_ALWAYS);
hammer2_chain_delete(trans, ochain);
hammer2_chain_unlock(ochain);
/*
* Then decrement nlinks on hardlink target, deleting
* the target when nlinks drops to 0.
*/
hammer2_chain_modify(trans, &chain, 0);
--chain->data->ipdata.nlinks;
if (chain->data->ipdata.nlinks == 0)
hammer2_chain_delete(trans, chain);
} else {
/*
* Otherwise this was not a hardlink and we can just
* remove the entry and decrement nlinks.
*
* NOTE: *_get() integrates chain's lock into the inode lock.
*/
hammer2_chain_modify(trans, &chain, 0);
ipdata = &chain->data->ipdata;
--ipdata->nlinks;
hammer2_chain_delete(trans, chain);
}
error = 0;
done:
if (chain)
hammer2_chain_unlock(chain);
if (parent)
hammer2_chain_lookup_done(parent);
if (ochain)
hammer2_chain_drop(ochain);
return error;
}
/*
* Connect the target inode represented by (*chainp) to the media topology
* at (dip, name, len).
*
* If hlink is TRUE this function creates an OBJTYPE_HARDLINK directory
* entry instead of connecting (*chainp).
*
* If hlink is FALSE this function uses chain_duplicate() to make a copy
* if (*chainp) in the directory entry. (*chainp) is likely to be deleted
* by the caller in this case (e.g. rename).
*/
int
hammer2_inode_connect(hammer2_trans_t *trans, int hlink,
hammer2_inode_t *dip, hammer2_chain_t **chainp,
const uint8_t *name, size_t name_len)
{
hammer2_inode_data_t *ipdata;
hammer2_chain_t *nchain;
hammer2_chain_t *parent;
hammer2_chain_t *ochain;
hammer2_key_t lhc;
int error;
ochain = *chainp;
/*
* Since ochain is either disconnected from the topology or represents
* a hardlink terminus which is always a parent of or equal to dip,
* we should be able to safely lock dip->chain for our setup.
*/
parent = hammer2_chain_lookup_init(dip->chain, 0);
lhc = hammer2_dirhash(name, name_len);
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*/
error = 0;
while (error == 0) {
nchain = hammer2_chain_lookup(&parent, lhc, lhc, 0);
if (nchain == NULL)
break;
if ((lhc & HAMMER2_DIRHASH_LOMASK) == HAMMER2_DIRHASH_LOMASK)
error = ENOSPC;
hammer2_chain_unlock(nchain);
nchain = NULL;
++lhc;
}
if (error == 0) {
if (hlink) {
/*
* Hardlink pointer needed, create totally fresh
* directory entry.
*/
KKASSERT(nchain == NULL);
error = hammer2_chain_create(trans, &parent, &nchain,
lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
hammer2_chain_refactor(&ochain);
} else {
/*
* Reconnect the original chain and rename. Use
* chain_duplicate(). The caller will likely delete
* or has already deleted the original chain in
* this case.
*
* NOTE: chain_duplicate() generates a new chain
* with CHAIN_DELETED cleared (ochain typically
* has it set from the file unlink).
*/
nchain = ochain;
ochain = NULL;
hammer2_chain_duplicate(trans, NULL, -1, &nchain, NULL);
error = hammer2_chain_create(trans, &parent, &nchain,
lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
}
}
/*
* Unlock stuff.
*/
KKASSERT(error != EAGAIN);
hammer2_chain_lookup_done(parent);
parent = NULL;
/*
* nchain should be NULL on error, leave ochain (== *chainp) alone.
*/
if (error) {
KKASSERT(nchain == NULL);
return (error);
}
/*
* Directory entries are inodes so if the name has changed we have
* to update the inode.
*
* When creating an OBJTYPE_HARDLINK entry remember to unlock the
* chain, the caller will access the hardlink via the actual hardlink
* target file and not the hardlink pointer entry, so we must still
* return ochain.
*/
if (hlink && hammer2_hardlink_enable >= 0) {
/*
* Create the HARDLINK pointer. oip represents the hardlink
* target in this situation.
*
* We will return ochain (the hardlink target).
*/
hammer2_chain_modify(trans, &nchain,
HAMMER2_MODIFY_ASSERTNOCOPY);
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
ipdata = &nchain->data->ipdata;
bcopy(name, ipdata->filename, name_len);
ipdata->name_key = lhc;
ipdata->name_len = name_len;
ipdata->target_type = ochain->data->ipdata.type;
ipdata->type = HAMMER2_OBJTYPE_HARDLINK;
ipdata->inum = ochain->data->ipdata.inum;
ipdata->nlinks = 1;
hammer2_chain_unlock(nchain);
nchain = ochain;
ochain = NULL;
} else if (hlink && hammer2_hardlink_enable < 0) {
/*
* Create a snapshot (hardlink fake mode for debugging).
* (ochain already flushed above so we can just copy the
* bref XXX).
*
* Since this is a snapshot we return nchain in the fake
* hardlink case.
*/
hammer2_chain_modify(trans, &nchain,
HAMMER2_MODIFY_ASSERTNOCOPY);
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
ipdata = &nchain->data->ipdata;
*ipdata = ochain->data->ipdata;
bcopy(name, ipdata->filename, name_len);
ipdata->name_key = lhc;
ipdata->name_len = name_len;
kprintf("created fake hardlink %*.*s\n",
(int)name_len, (int)name_len, name);
} else {
/*
* nchain is a duplicate of ochain at the new location.
* We must fixup the name stored in oip. The bref key
* has already been set up.
*/
hammer2_chain_modify(trans, &nchain,
HAMMER2_MODIFY_ASSERTNOCOPY);
ipdata = &nchain->data->ipdata;
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, ipdata->filename, name_len);
ipdata->name_key = lhc;
ipdata->name_len = name_len;
ipdata->nlinks = 1;
}
/*
* We are replacing ochain with nchain, unlock ochain. In the
* case where ochain is left unchanged the code above sets
* nchain to ochain and ochain to NULL, resulting in a NOP here.
*/
if (ochain)
hammer2_chain_unlock(ochain);
*chainp = nchain;
return (0);
}
/*
* Create a directory entry under dip with the specified name, inode number,
* and OBJTYPE (type).
*
* This returns a UNIX errno code, not a HAMMER2_ERROR_* code.
*
* Caller must hold dip locked.
*/
int
hammer2_dirent_create(hammer2_inode_t *dip, const char *name, size_t name_len,
hammer2_key_t inum, uint8_t type)
{
hammer2_xop_mkdirent_t *xop;
hammer2_key_t lhc;
int error;
lhc = 0;
error = 0;
KKASSERT(name != NULL);
lhc = hammer2_dirhash(name, name_len);
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*
* Lock the directory exclusively for now to guarantee that
* we can find an unused lhc for the name. Due to collisions,
* two different creates can end up with the same lhc so we
* cannot depend on the OS to prevent the collision.
*/
hammer2_inode_modify(dip);
/*
* If name specified, locate an unused key in the collision space.
* Otherwise use the passed-in lhc directly.
*/
{
hammer2_xop_scanlhc_t *sxop;
hammer2_key_t lhcbase;
lhcbase = lhc;
sxop = hammer2_xop_alloc(dip, HAMMER2_XOP_MODIFYING);
sxop->lhc = lhc;
hammer2_xop_start(&sxop->head, &hammer2_scanlhc_desc);
while ((error = hammer2_xop_collect(&sxop->head, 0)) == 0) {
if (lhc != sxop->head.cluster.focus->bref.key)
break;
++lhc;
}
hammer2_xop_retire(&sxop->head, HAMMER2_XOPMASK_VOP);
if (error) {
if (error != HAMMER2_ERROR_ENOENT)
goto done2;
++lhc;
error = 0;
}
if ((lhcbase ^ lhc) & ~HAMMER2_DIRHASH_LOMASK) {
error = HAMMER2_ERROR_ENOSPC;
goto done2;
}
}
/*
* Create the directory entry with the lhc as the key.
*/
xop = hammer2_xop_alloc(dip, HAMMER2_XOP_MODIFYING);
xop->lhc = lhc;
bzero(&xop->dirent, sizeof(xop->dirent));
xop->dirent.inum = inum;
xop->dirent.type = type;
xop->dirent.namlen = name_len;
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
hammer2_xop_setname(&xop->head, name, name_len);
hammer2_xop_start(&xop->head, &hammer2_inode_mkdirent_desc);
error = hammer2_xop_collect(&xop->head, 0);
hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
done2:
error = hammer2_error_to_errno(error);
return error;
}
/*
* Create a PFS inode under the superroot. This function will create the
* inode, its media chains, and also insert it into the media.
*
* Caller must be in a flush transaction because we are inserting the inode
* onto the media.
*/
hammer2_inode_t *
hammer2_inode_create_pfs(hammer2_pfs_t *spmp,
const uint8_t *name, size_t name_len,
int *errorp)
{
hammer2_xop_create_t *xop;
hammer2_inode_t *pip;
hammer2_inode_t *nip;
int error;
uuid_t pip_uid;
uuid_t pip_gid;
uint32_t pip_mode;
uint8_t pip_comp_algo;
uint8_t pip_check_algo;
hammer2_tid_t pip_inum;
hammer2_key_t lhc;
pip = spmp->iroot;
nip = NULL;
lhc = hammer2_dirhash(name, name_len);
*errorp = 0;
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*
* Lock the directory exclusively for now to guarantee that
* we can find an unused lhc for the name. Due to collisions,
* two different creates can end up with the same lhc so we
* cannot depend on the OS to prevent the collision.
*/
hammer2_inode_lock(pip, 0);
pip_uid = pip->meta.uid;
pip_gid = pip->meta.gid;
pip_mode = pip->meta.mode;
pip_comp_algo = pip->meta.comp_algo;
pip_check_algo = pip->meta.check_algo;
pip_inum = (pip == pip->pmp->iroot) ? 1 : pip->meta.inum;
/*
* Locate an unused key in the collision space.
*/
{
hammer2_xop_scanlhc_t *sxop;
hammer2_key_t lhcbase;
lhcbase = lhc;
sxop = hammer2_xop_alloc(pip, HAMMER2_XOP_MODIFYING);
sxop->lhc = lhc;
hammer2_xop_start(&sxop->head, &hammer2_scanlhc_desc);
while ((error = hammer2_xop_collect(&sxop->head, 0)) == 0) {
if (lhc != sxop->head.cluster.focus->bref.key)
break;
++lhc;
}
hammer2_xop_retire(&sxop->head, HAMMER2_XOPMASK_VOP);
if (error) {
if (error != HAMMER2_ERROR_ENOENT)
goto done2;
++lhc;
error = 0;
}
if ((lhcbase ^ lhc) & ~HAMMER2_DIRHASH_LOMASK) {
error = HAMMER2_ERROR_ENOSPC;
goto done2;
}
}
/*
* Create the inode with the lhc as the key.
*/
xop = hammer2_xop_alloc(pip, HAMMER2_XOP_MODIFYING);
xop->lhc = lhc;
xop->flags = HAMMER2_INSERT_PFSROOT;
bzero(&xop->meta, sizeof(xop->meta));
xop->meta.type = HAMMER2_OBJTYPE_DIRECTORY;
xop->meta.inum = 1;
xop->meta.iparent = pip_inum;
/* Inherit parent's inode compression mode. */
xop->meta.comp_algo = pip_comp_algo;
xop->meta.check_algo = pip_check_algo;
xop->meta.version = HAMMER2_INODE_VERSION_ONE;
hammer2_update_time(&xop->meta.ctime);
xop->meta.mtime = xop->meta.ctime;
xop->meta.mode = 0755;
xop->meta.nlinks = 1;
/*
* Regular files and softlinks allow a small amount of data to be
* directly embedded in the inode. This flag will be cleared if
* the size is extended past the embedded limit.
*/
if (xop->meta.type == HAMMER2_OBJTYPE_REGFILE ||
xop->meta.type == HAMMER2_OBJTYPE_SOFTLINK) {
xop->meta.op_flags |= HAMMER2_OPFLAG_DIRECTDATA;
}
hammer2_xop_setname(&xop->head, name, name_len);
xop->meta.name_len = name_len;
xop->meta.name_key = lhc;
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
hammer2_xop_start(&xop->head, &hammer2_inode_create_desc);
error = hammer2_xop_collect(&xop->head, 0);
#if INODE_DEBUG
kprintf("CREATE INODE %*.*s\n",
(int)name_len, (int)name_len, name);
#endif
if (error) {
*errorp = error;
goto done;
}
/*
* Set up the new inode if not a hardlink pointer.
*
* NOTE: *_get() integrates chain's lock into the inode lock.
*
* NOTE: Only one new inode can currently be created per
* transaction. If the need arises we can adjust
* hammer2_trans_init() to allow more.
*
* NOTE: nipdata will have chain's blockset data.
*/
nip = hammer2_inode_get(pip->pmp, &xop->head, -1, -1);
nip->comp_heuristic = 0;
done:
hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
done2:
hammer2_inode_unlock(pip);
return (nip);
}
/*
* Create a snapshot of the specified {parent, ochain} with the specified
* label. The originating hammer2_inode must be exclusively locked for
* safety.
*
* The ioctl code has already synced the filesystem.
*/
int
hammer2_cluster_snapshot(hammer2_trans_t *trans, hammer2_cluster_t *ocluster,
hammer2_ioc_pfs_t *pfs)
{
hammer2_mount_t *hmp;
hammer2_cluster_t *ncluster;
const hammer2_inode_data_t *ipdata;
hammer2_inode_data_t *wipdata;
hammer2_inode_t *nip;
size_t name_len;
hammer2_key_t lhc;
struct vattr vat;
uuid_t opfs_clid;
int error;
kprintf("snapshot %s\n", pfs->name);
name_len = strlen(pfs->name);
lhc = hammer2_dirhash(pfs->name, name_len);
ipdata = &hammer2_cluster_data(ocluster)->ipdata;
opfs_clid = ipdata->pfs_clid;
hmp = ocluster->focus->hmp;
/*
* Create the snapshot directory under the super-root
*
* Set PFS type, generate a unique filesystem id, and generate
* a cluster id. Use the same clid when snapshotting a PFS root,
* which theoretically allows the snapshot to be used as part of
* the same cluster (perhaps as a cache).
*
* Copy the (flushed) blockref array. Theoretically we could use
* chain_duplicate() but it becomes difficult to disentangle
* the shared core so for now just brute-force it.
*/
VATTR_NULL(&vat);
vat.va_type = VDIR;
vat.va_mode = 0755;
ncluster = NULL;
nip = hammer2_inode_create(trans, hmp->spmp->iroot, &vat,
proc0.p_ucred, pfs->name, name_len,
&ncluster, &error);
if (nip) {
wipdata = hammer2_cluster_modify_ip(trans, nip, ncluster, 0);
wipdata->pfs_type = HAMMER2_PFSTYPE_SNAPSHOT;
kern_uuidgen(&wipdata->pfs_fsid, 1);
if (ocluster->focus->flags & HAMMER2_CHAIN_PFSROOT)
wipdata->pfs_clid = opfs_clid;
else
kern_uuidgen(&wipdata->pfs_clid, 1);
hammer2_cluster_set_chainflags(ncluster, HAMMER2_CHAIN_PFSROOT);
/* XXX hack blockset copy */
/* XXX doesn't work with real cluster */
KKASSERT(ocluster->nchains == 1);
wipdata->u.blockset = ocluster->focus->data->ipdata.u.blockset;
hammer2_cluster_modsync(ncluster);
hammer2_inode_unlock_ex(nip, ncluster);
}
return (error);
}
/*
* Unlink the file from the specified directory inode. The directory inode
* does not need to be locked.
*
* isdir determines whether a directory/non-directory check should be made.
* No check is made if isdir is set to -1.
*/
int
hammer2_unlink_file(hammer2_inode_t *dip,
const uint8_t *name, size_t name_len,
int isdir, hammer2_inode_t *retain_ip)
{
hammer2_mount_t *hmp;
hammer2_chain_t *parent;
hammer2_chain_t *chain;
hammer2_chain_t *dparent;
hammer2_chain_t *dchain;
hammer2_key_t lhc;
hammer2_inode_t *ip;
hammer2_inode_t *oip;
int error;
uint8_t type;
error = 0;
oip = NULL;
hmp = dip->hmp;
lhc = hammer2_dirhash(name, name_len);
/*
* Search for the filename in the directory
*/
parent = &dip->chain;
hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
chain = hammer2_chain_lookup(hmp, &parent,
lhc, lhc + HAMMER2_DIRHASH_LOMASK,
0);
while (chain) {
if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
chain->u.ip &&
name_len == chain->data->ipdata.name_len &&
bcmp(name, chain->data->ipdata.filename, name_len) == 0) {
break;
}
chain = hammer2_chain_next(hmp, &parent, chain,
lhc, lhc + HAMMER2_DIRHASH_LOMASK,
0);
}
/*
* Not found or wrong type (isdir < 0 disables the type check).
*/
if (chain == NULL) {
hammer2_chain_unlock(hmp, parent);
return ENOENT;
}
if ((type = chain->data->ipdata.type) == HAMMER2_OBJTYPE_HARDLINK)
type = chain->data->ipdata.target_type;
if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir == 0) {
error = ENOTDIR;
goto done;
}
if (type != HAMMER2_OBJTYPE_DIRECTORY && isdir == 1) {
error = EISDIR;
goto done;
}
/*
* Hardlink must be resolved. We can't hold parent locked while we
* do this or we could deadlock.
*/
if (chain->data->ipdata.type == HAMMER2_OBJTYPE_HARDLINK) {
hammer2_chain_unlock(hmp, parent);
parent = NULL;
error = hammer2_hardlink_find(dip, &chain, &oip);
}
/*
* If this is a directory the directory must be empty. However, if
* isdir < 0 we are doing a rename and the directory does not have
* to be empty.
*
* NOTE: We check the full key range here which covers both visible
* and invisible entries. Theoretically there should be no
* invisible (hardlink target) entries if there are no visible
* entries.
*/
if (type == HAMMER2_OBJTYPE_DIRECTORY && isdir >= 0) {
dparent = chain;
hammer2_chain_lock(hmp, dparent, HAMMER2_RESOLVE_ALWAYS);
dchain = hammer2_chain_lookup(hmp, &dparent,
0, (hammer2_key_t)-1,
HAMMER2_LOOKUP_NODATA);
if (dchain) {
hammer2_chain_unlock(hmp, dchain);
hammer2_chain_unlock(hmp, dparent);
error = ENOTEMPTY;
goto done;
}
hammer2_chain_unlock(hmp, dparent);
dparent = NULL;
/* dchain NULL */
}
/*
* Ok, we can now unlink the chain. We always decrement nlinks even
* if the entry can be deleted in case someone has the file open and
* does an fstat().
*
* The chain itself will no longer be in the on-media topology but
* can still be flushed to the media (e.g. if an open descriptor
* remains). When the last vnode/ip ref goes away the chain will
* be marked unmodified, avoiding any further (now unnecesary) I/O.
*/
if (oip) {
/*
* If this was a hardlink we first delete the hardlink
* pointer entry.
*/
parent = oip->chain.parent;
hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
hammer2_chain_lock(hmp, &oip->chain, HAMMER2_RESOLVE_ALWAYS);
hammer2_chain_delete(hmp, parent, &oip->chain,
(retain_ip == oip));
hammer2_chain_unlock(hmp, &oip->chain);
hammer2_chain_unlock(hmp, parent);
parent = NULL;
/*
* Then decrement nlinks on hardlink target.
*/
ip = chain->u.ip;
if (ip->ip_data.nlinks == 1) {
dparent = chain->parent;
hammer2_chain_ref(hmp, chain);
hammer2_chain_unlock(hmp, chain);
hammer2_chain_lock(hmp, dparent,
HAMMER2_RESOLVE_ALWAYS);
hammer2_chain_lock(hmp, chain, HAMMER2_RESOLVE_ALWAYS);
hammer2_chain_drop(hmp, chain);
hammer2_chain_modify(hmp, chain, 0);
--ip->ip_data.nlinks;
hammer2_chain_delete(hmp, dparent, chain, 0);
hammer2_chain_unlock(hmp, dparent);
} else {
hammer2_chain_modify(hmp, chain, 0);
--ip->ip_data.nlinks;
}
} else {
/*
* Otherwise this was not a hardlink and we can just
* remove the entry and decrement nlinks.
*/
ip = chain->u.ip;
hammer2_chain_modify(hmp, chain, 0);
--ip->ip_data.nlinks;
hammer2_chain_delete(hmp, parent, chain,
(retain_ip == ip));
}
error = 0;
done:
if (chain)
hammer2_chain_unlock(hmp, chain);
if (parent)
hammer2_chain_unlock(hmp, parent);
if (oip)
hammer2_chain_drop(oip->hmp, &oip->chain);
return error;
}
/*
* Connect inode (oip) to the specified directory using the specified name.
* (oip) must be locked.
*
* If (oip) is not currently connected we simply connect it up.
*
* If (oip) is already connected we create a OBJTYPE_HARDLINK entry which
* points to (oip)'s inode number. (oip) is expected to be the terminus of
* the hardlink sitting as a hidden file in a common parent directory
* in this situation (thus the lock order is correct).
*/
int
hammer2_inode_connect(hammer2_inode_t *dip, hammer2_inode_t *oip,
const uint8_t *name, size_t name_len)
{
hammer2_mount_t *hmp = dip->hmp;
hammer2_chain_t *chain;
hammer2_chain_t *parent;
hammer2_inode_t *nip;
hammer2_key_t lhc;
int error;
int hlink;
lhc = hammer2_dirhash(name, name_len);
hlink = (oip->chain.parent != NULL);
/*
* In fake mode flush oip so we can just snapshot it downbelow.
*/
if (hlink && hammer2_hardlink_enable < 0)
hammer2_chain_flush(hmp, &oip->chain, 0);
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*/
parent = &dip->chain;
hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
error = 0;
while (error == 0) {
chain = hammer2_chain_lookup(hmp, &parent, lhc, lhc, 0);
if (chain == NULL)
break;
if ((lhc & HAMMER2_DIRHASH_LOMASK) == HAMMER2_DIRHASH_LOMASK)
error = ENOSPC;
hammer2_chain_unlock(hmp, chain);
chain = NULL;
++lhc;
}
/*
* Passing a non-NULL chain to hammer2_chain_create() reconnects the
* existing chain instead of creating a new one. The chain's bref
* will be properly updated.
*/
if (error == 0) {
if (hlink) {
chain = hammer2_chain_create(hmp, parent,
NULL, lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
} else {
chain = hammer2_chain_create(hmp, parent,
&oip->chain, lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
if (chain)
KKASSERT(chain == &oip->chain);
}
if (chain == NULL)
error = EIO;
}
hammer2_chain_unlock(hmp, parent);
/*
* Handle the error case
*/
if (error) {
KKASSERT(chain == NULL);
return (error);
}
/*
* Directory entries are inodes so if the name has changed we have
* to update the inode.
*
* When creating an OBJTYPE_HARDLINK entry remember to unlock the
* chain, the caller will access the hardlink via the actual hardlink
* target file and not the hardlink pointer entry.
*/
if (hlink && hammer2_hardlink_enable >= 0) {
/*
* Create the HARDLINK pointer. oip represents the hardlink
* target in this situation.
*/
nip = chain->u.ip;
hammer2_chain_modify(hmp, chain, 0);
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, nip->ip_data.filename, name_len);
nip->ip_data.name_key = lhc;
nip->ip_data.name_len = name_len;
nip->ip_data.target_type = oip->ip_data.type;
nip->ip_data.type = HAMMER2_OBJTYPE_HARDLINK;
nip->ip_data.inum = oip->ip_data.inum;
nip->ip_data.nlinks = 1;
kprintf("created hardlink %*.*s\n",
(int)name_len, (int)name_len, name);
hammer2_chain_unlock(hmp, chain);
} else if (hlink && hammer2_hardlink_enable < 0) {
/*
* Create a snapshot (hardlink fake mode for debugging).
*/
nip = chain->u.ip;
nip->ip_data = oip->ip_data;
hammer2_chain_modify(hmp, chain, 0);
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, nip->ip_data.filename, name_len);
nip->ip_data.name_key = lhc;
nip->ip_data.name_len = name_len;
kprintf("created fake hardlink %*.*s\n",
(int)name_len, (int)name_len, name);
hammer2_chain_unlock(hmp, chain);
} else {
/*
* Normally disconnected inode (e.g. during a rename) that
* was reconnected. We must fixup the name stored in
* oip.
*
* We are using oip as chain, already locked by caller,
* do not unlock it.
*/
hammer2_chain_modify(hmp, chain, 0);
if (oip->ip_data.name_len != name_len ||
bcmp(oip->ip_data.filename, name, name_len) != 0) {
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, oip->ip_data.filename, name_len);
oip->ip_data.name_key = lhc;
oip->ip_data.name_len = name_len;
}
oip->ip_data.nlinks = 1;
}
return (0);
}
/*
* Duplicate the specified existing inode in the specified target directory.
* If name is NULL the inode is duplicated as a hidden directory entry.
*
* Returns the new inode. The old inode is left alone.
*
* XXX name needs to be NULL for now.
*/
int
hammer2_inode_duplicate(hammer2_inode_t *dip, hammer2_inode_t *oip,
hammer2_inode_t **nipp,
const uint8_t *name, size_t name_len)
{
hammer2_mount_t *hmp = dip->hmp;
hammer2_inode_t *nip;
hammer2_chain_t *parent;
hammer2_chain_t *chain;
hammer2_key_t lhc;
int error;
if (name) {
lhc = hammer2_dirhash(name, name_len);
} else {
lhc = oip->ip_data.inum;
KKASSERT((lhc & HAMMER2_DIRHASH_VISIBLE) == 0);
}
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*/
nip = NULL;
parent = &dip->chain;
hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
error = 0;
while (error == 0) {
chain = hammer2_chain_lookup(hmp, &parent, lhc, lhc, 0);
if (chain == NULL)
break;
/* XXX bcmp name if not NULL */
if ((lhc & HAMMER2_DIRHASH_LOMASK) == HAMMER2_DIRHASH_LOMASK)
error = ENOSPC;
if ((lhc & HAMMER2_DIRHASH_VISIBLE) == 0) /* shouldn't happen */
error = ENOSPC;
hammer2_chain_unlock(hmp, chain);
chain = NULL;
++lhc;
}
/*
* Create entry in common parent directory.
*/
if (error == 0) {
chain = hammer2_chain_create(hmp, parent, NULL, lhc, 0,
HAMMER2_BREF_TYPE_INODE /* n/a */,
HAMMER2_INODE_BYTES); /* n/a */
if (chain == NULL)
error = EIO;
}
hammer2_chain_unlock(hmp, parent);
/*
* Handle the error case
*/
if (error) {
KKASSERT(chain == NULL);
return (error);
}
/*
* XXX This is currently a horrible hack. Well, if we wanted to
* duplicate a file, i.e. as in a snapshot, we definitely
* would have to flush it first.
*
* For hardlink target generation we can theoretically move any
* active chain structures without flushing, but that gets really
* iffy for code which follows chain->parent and ip->pip links.
*
* XXX only works with files. Duplicating a directory hierarchy
* requires a flush but doesn't deal with races post-flush.
* Well, it would work I guess, but you might catch some files
* mid-operation.
*
* We cannot leave oip with any in-memory chains because (for a
* hardlink), oip will become a OBJTYPE_HARDLINK which is just a
* pointer to the real hardlink's inum and can't have any sub-chains.
* XXX might be 0-ref chains left.
*/
hammer2_inode_lock_ex(oip);
hammer2_chain_flush(hmp, &oip->chain, 0);
hammer2_inode_unlock_ex(oip);
/*KKASSERT(RB_EMPTY(&oip->chain.rbhead));*/
nip = chain->u.ip;
hammer2_chain_modify(hmp, chain, 0);
nip->ip_data = oip->ip_data; /* sync media data after flush */
if (name) {
/*
* Directory entries are inodes so if the name has changed
* we have to update the inode.
*/
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, nip->ip_data.filename, name_len);
nip->ip_data.name_key = lhc;
nip->ip_data.name_len = name_len;
} else {
/*
* Directory entries are inodes but this is a hidden hardlink
* target. The name isn't used but to ease debugging give it
* a name after its inode number.
*/
ksnprintf(nip->ip_data.filename, sizeof(nip->ip_data.filename),
"0x%016jx", (intmax_t)nip->ip_data.inum);
nip->ip_data.name_len = strlen(nip->ip_data.filename);
nip->ip_data.name_key = lhc;
}
*nipp = nip;
return (0);
}
/*
* Create a new inode in the specified directory using the vattr to
* figure out the type of inode.
*
* If no error occurs the new inode with its chain locked is returned in
* *nipp, otherwise an error is returned and *nipp is set to NULL.
*
* If vap and/or cred are NULL the related fields are not set and the
* inode type defaults to a directory. This is used when creating PFSs
* under the super-root, so the inode number is set to 1 in this case.
*/
int
hammer2_inode_create(hammer2_inode_t *dip,
struct vattr *vap, struct ucred *cred,
const uint8_t *name, size_t name_len,
hammer2_inode_t **nipp)
{
hammer2_mount_t *hmp = dip->hmp;
hammer2_chain_t *chain;
hammer2_chain_t *parent;
hammer2_inode_t *nip;
hammer2_key_t lhc;
int error;
uid_t xuid;
lhc = hammer2_dirhash(name, name_len);
/*
* Locate the inode or indirect block to create the new
* entry in. At the same time check for key collisions
* and iterate until we don't get one.
*/
parent = &dip->chain;
hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS);
error = 0;
while (error == 0) {
chain = hammer2_chain_lookup(hmp, &parent, lhc, lhc, 0);
if (chain == NULL)
break;
if ((lhc & HAMMER2_DIRHASH_VISIBLE) == 0)
error = ENOSPC;
if ((lhc & HAMMER2_DIRHASH_LOMASK) == HAMMER2_DIRHASH_LOMASK)
error = ENOSPC;
hammer2_chain_unlock(hmp, chain);
chain = NULL;
++lhc;
}
if (error == 0) {
chain = hammer2_chain_create(hmp, parent, NULL, lhc, 0,
HAMMER2_BREF_TYPE_INODE,
HAMMER2_INODE_BYTES);
if (chain == NULL)
error = EIO;
}
hammer2_chain_unlock(hmp, parent);
/*
* Handle the error case
*/
if (error) {
KKASSERT(chain == NULL);
*nipp = NULL;
return (error);
}
/*
* Set up the new inode
*/
nip = chain->u.ip;
*nipp = nip;
hammer2_voldata_lock(hmp);
if (vap) {
nip->ip_data.type = hammer2_get_obj_type(vap->va_type);
nip->ip_data.inum = hmp->voldata.alloc_tid++;
/* XXX modify/lock */
} else {
nip->ip_data.type = HAMMER2_OBJTYPE_DIRECTORY;
nip->ip_data.inum = 1;
}
hammer2_voldata_unlock(hmp);
nip->ip_data.version = HAMMER2_INODE_VERSION_ONE;
hammer2_update_time(&nip->ip_data.ctime);
nip->ip_data.mtime = nip->ip_data.ctime;
if (vap)
nip->ip_data.mode = vap->va_mode;
nip->ip_data.nlinks = 1;
if (vap) {
if (dip) {
xuid = hammer2_to_unix_xid(&dip->ip_data.uid);
xuid = vop_helper_create_uid(dip->pmp->mp,
dip->ip_data.mode,
xuid,
cred,
&vap->va_mode);
} else {
xuid = 0;
}
/* XXX
if (vap->va_vaflags & VA_UID_UUID_VALID)
nip->ip_data.uid = vap->va_uid_uuid;
else if (vap->va_uid != (uid_t)VNOVAL)
hammer2_guid_to_uuid(&nip->ip_data.uid, vap->va_uid);
else
*/
hammer2_guid_to_uuid(&nip->ip_data.uid, xuid);
/* XXX if (vap->va_vaflags & VA_GID_UUID_VALID)
nip->ip_data.gid = vap->va_gid_uuid;
else if (vap->va_gid != (gid_t)VNOVAL)
hammer2_guid_to_uuid(&nip->ip_data.gid, vap->va_gid);
else */ if (dip)
nip->ip_data.gid = dip->ip_data.gid;
}
/*
* Regular files and softlinks allow a small amount of data to be
* directly embedded in the inode. This flag will be cleared if
* the size is extended past the embedded limit.
*/
if (nip->ip_data.type == HAMMER2_OBJTYPE_REGFILE ||
nip->ip_data.type == HAMMER2_OBJTYPE_SOFTLINK) {
nip->ip_data.op_flags |= HAMMER2_OPFLAG_DIRECTDATA;
}
KKASSERT(name_len < HAMMER2_INODE_MAXNAME);
bcopy(name, nip->ip_data.filename, name_len);
nip->ip_data.name_key = lhc;
nip->ip_data.name_len = name_len;
return (0);
}